json-valid-3k
v1.4.0
Published
A simple tool for validating complex JSON structures
Downloads
25
Maintainers
Readme
json-valid-3k
Validate or generate JSON-like structures with schemas
Usage - simple
import { validate } from 'json-valid-3k'
const data = {
arr: [],
num: 3,
str: 'High quality string',
}
const schema = {
arr: 'Array',
num: 'Number',
str: 'String',
}
const test = validate(data, schema)
Validation response object
{
valid: boolean
tree: { YOUR_OBJECT_PROPS / ERRORS },
errors: Map<K, V> // A flat list displaying the exact depth position of each failed value
dropped: Map<K, V> // Shows the errors for silently dropped items (silentDrop: true)
}
The tree
object stores your output. It contains the relevant value OR error for each key:value pair.
Discards everything not in the schema. The idea is that if you really care about your data integrity, than there's not reason not to use it as opposed to dragging everything esle from your source object.
Usage - expanded
import { validate } from 'json-valid-3k'
// OR
// const { validate } = require('json-valid-3k')
const CFG_SIMPLE = {
arr: [], // 01. Array
boo: true, // 02. Boolean
elm: document.createElement('div'), // 03. Element
fun: () => {}, // 04. Function
num: 3, // 05. Number
obj: {}, // 06. Object
str: 'High quality string', // 07. String
url: 'https://some.place.com', // 08. URL
mail: '[email protected]', // 09. ValidEmail
ip: '192.168.0.251', // 10. ValidIP
def: null, // 11. null
}
const SCHEMA_SIMPLE = {
arr: 'Array', // { type: 'Array' },
boo: 'Boolean', // { type: 'Boolean' },
elm: 'Element', // { type: 'Element' },
fun: 'Function', // { type: 'Function' },
num: 'Number', // { type: 'Number' },
obj: 'Object', // { type: 'Object' },
str: 'String', // { type: 'String' },
url: 'URL', // { type: 'URL' },
mail: 'ValidEmail', // { type: 'ValidEmail' },
ip: 'ValidIP', // { type: 'ValidIP' },
def: null, // { type: null },
}
const test = validate(CFG_SIMPLE, SCHEMA_SIMPLE)
Types
Predefined Types
01. Array
02. Boolean
03. Element
04. Function
05. Number
06. Object
07. String
08. URL
09. ValidEmail
10. ValidIP
Custom types
Adding custom types is simple. This is exactly what json-validate-3k
is using internally for its predefined types.
import { validate, types } from 'json-valid-3k'
types.set('LongString', (v) => {
return typeof v === 'string' && v.length > 255
})
Custom functions as rules
Sometimes even custom type aren't enough and we have to reach for something more.
import { validate } from 'json-valid-3k'
const dataObject = {
abc: 'AaBbCc',
arr: [1, 2, 3, 4, 5]
}
const dataSchema = {
abc: 'String',
arr: (value, data, schema) => {
return Array.isArray(value) && value.length > 3
}
}
// Your validation object
const { valid, tree, errors, dropped } = validate(dataObject, dataSchema)
Multiple possible types per value
Every value can be targeted via one or more rule types
const SCHEMA_MULTIPLE = {
aaa: 'Array',
bbb: ['Array', 'Number'],
ccc: ['String', 'Object', null]
}
Additional Schema Options
{
// ...Some props
optional: Boolean,
default: 'Something', // Has to match the type. NOT applied when "optional" is "true"
allowEmpty: Boolean, // Default value is true. Using false fails empty Array/Object/String values
silentDrop: Boolean, // Default value is false. Using true drops failed items without raising the alarm
}
Usage - deep nesting
import { validate } from 'json-valid-3k'
const a_data = {
a: 'kisk',
b: {
duck: 123,
bb: 123,
xx: {
q: [
{ qub: 456 },
{ qub: 789 },
{ qub: 'I am wrong, hehe' },
null,
undefined,
{ irrelevant: 'prop' },
{ qub: 111 },
]
},
yy: {
hello: 'World',
},
},
c: ['Dingo'],
d: () => ({}),
}
const a_schema = {
a: { type: 'String', optional: true },
c: { type: 'Array', optional: false },
b: {
type: 'Object',
optional: true,
props: {
duck: { type: 'String', optional: true },
bb: { type: 'Number', optional: false },
xx: {
type: 'Object',
props: {
q: {
type: 'Array',
children: {
type: 'Object',
props: { qub: { type: 'Number' } },
},
},
},
},
yy: {
type: 'Object',
props: {
hello: { type: 'String' },
aaa: { type: 'Boolean', default: false },
bbb: { type: 'Boolean', default: true },
ccc: { type: null, default: null },
ddd: { type: null, default: undefined },
eee: { type: 'String', default: 'This will show up', },
fff: { type: 'String', default: 'This will NOT show up because it is optional', optional: true },
},
},
},
},
d: { type: 'Function' }
}
const test = validate(a_data, a_schema)
test = {
valid: false, // OR true
tree: {
a: "kisk"
b:
bb: 123
duck: "ERROR: Value [123] does not match type [String]"
xx: {
q: Array(7) [
0: {qub: 456}
1: {qub: 789}
2: {qub: "ERROR: Value ["I am wrong, hehe"] does not match type [Number]"}
3: "ERROR: Value [null] does not match type [Object]"
4: "ERROR: Value [undefined] does not match type [Object]"
5: {qub: "ERROR: Value [undefined] does not match type [Number]"}
6: {qub: 111}
]
}
yy: {
aaa: false
bbb: true
ccc: null
ddd: "ERROR: Value [undefined] does not match type [null]"
eee: "This will show up"
hello: "World"
}
c: ["Dingo"]
d: () => ({})
},
}