Convert JS object to JSON Schema
npm install json2json-schemaConverts javascript objects (and other types) to corresponding JSON schema
``
npm install json2json-schema
javascript
const toJsonSchema = require('json2json-schema');const objToBeConverted = {
name: 'David',
rank: 7,
born: '1990-04-05T15:09:56.704Z',
luckyNumbers: [7, 77, 5]
};
const schema = toJsonSchema(objToBeConverted);
` generated from above code will look like this:`javascript
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"rank": {
"type": "integer"
},
"born": {
"type": "string",
"format": "date-time"
},
"luckyNumbers": {
"type": "array",
"items": {
"type": "integer"
}
}
}
}
` exports function that converts most javascript values to JSON schema. Such a schema can be used to
further validation of similar objects/values*
value: required Any javascript value
* options: optional options object Options
$3
Possible option values
required
(
true|false default is false)
specify true to make all properties required.`javascript
const schema = toJsonSchema(33, {required: false});
/*
{
"type": "integer"
}
*/
`javascript
const schema = toJsonSchema(33, {required: true});
/*
{
"type": "integer",
"required": true
}
*/
`postProcessFnc (
)parameters:
- type (string) - JSON schema type of the
value
- schema (object) - Generated JSON schema
- value - (any) - input value
- defaultFunc (function) - standard function that is used to post-process generated schema. Takes the , schema, value params.By providing
postProcessFnc, you can modify or replace generated schema. This function
will be called recursively for all the properties and sub-properties and array items from leaves to the root.
If you want to preserve default functionality, don't forget to call defaultFunc which is currently responsible for setting
required for the schema items if there is common option required set tu true.
Following example is showing configuration options leading to all integer values to be automatically required
`javascript
const options = {
postProcessFnc: (type, schema, value, defaultFunc) =>
(type === 'integer') ? {...schema, required: true} : defaultFunc(type, schema, value),
}const instance = {
a: 1,
b: 'str',
}
const schema = toJsonSchema(instance, options);
/*
{
type: 'object',
properties: {
a: {type: 'integer', required: true},
b: {type: 'string'},
},
}*/
`
$3
arrays.mode (
default is all)
all option causes parser to go through all array items, finding the most compatible yet most descriptive schema possible. Array items are all of compatible type:
`javascript
const arr = [33, 44, 55];
const schema = toJsonSchema(arr, {arrays: {mode: 'all'}});
/*
{
"type": "array",
"items": {
"type": "integer"
}
}
*/
`Items' types are incompatible. Type is omitted in schema to be able to validate input object:
javascript
const arr = [33, 'str', 55];
const schema = toJsonSchema(arr, {arrays: {mode: 'all'}});
/*
{
"type": "array"
}
*/
`Incompatible in sub-item. Schema still describes object properties
javascript
const arr = [
{name: 'john', grades: [1, 2, 3]},
{name: 'david', grades: ['a', 'b', 'c']}
];
const schema = toJsonSchema(arr, {arrays: {mode: 'all'}});
/*
{
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"grades": {
"type": "array" // due to incompatible array items' types, items field is omitted
}
}
}
}
*/
` option takes only first item in the array into account. If performance
is a concern, you may consider this option. `javascript
const arr = ['str', 11, 30];
const schema = toJsonSchema(arr, {arrays: {mode: 'first'}});
/* Other than first array item is ignored
{
"type": "array",
"items": {
"type": "string"
}
}
*/
` option requires all items in array to have same structure (to convert to the same schema).
If not, error is thrown. `javascript
const arr = ['str', 11, 30];
const schema = toJsonSchema(arr, {arrays: {mode: 'uniform'}});
/*
Above code will throw 'Error: Invalid schema, incompatible array items'
*/
` option generates a tuple array
(array of objects) from arrays.`javascript
const arr = ['str', 11, 30];
const schema = toJsonSchema(arr, {arrays: {mode: 'tuple'}});
/*
{
"type": "array",
"items": [
{
"type": "string"
},
{
"type": "integer"
},
{
"type": "integer"
}
]
}
*/
`
$3
objects.additionalProperties (
, default true)if set to
false, all object schemas will include JSON schema property additionalProperties: false which makes generated schema
to perevent any extra properties.`javascript
const options = {
objects: {additionalProperties: false},
}
const obj = {
a: {
c: 1,
d: 1,
},
b: 'str',
}
const schema = toJsonSchema(obj, options);
/*
{
type: 'object',
properties: {
a: {
type: 'object',
properties: {
c: {type: 'integer'},
d: {type: 'integer'},
},
additionalProperties: false,
},
b: {type: 'string'},
},
additionalProperties: false,
}
*/
`objects.preProcessFnc (
)parameters:
- obj - (object) - input object value that is supposed to be converted into JSON schema
- defaultFunc (function) - standard function that is used to generate schema from object. Takes just the
obj param.By providing custom function you will be able to modify any object value (including nested ones) and pre-process
it before it gets converted into schema or modify generated schema or do the schema conversion entirely by yourself.
Custom function from example bellow ignores all properties other than
a and b from input object:
`javascript
const options = {
objects: {
preProcessFnc: (obj, defaultFnc) => defaultFnc({a: obj.a, b: obj.b})
}
};
const obj = {a: 1, b: 2, c: 3};
const schema = toJsonSchema(obj, options);
/*
{
"type": "object",
"properties": {
"a": {
"type": "integer"
},
"b": {
"type": "integer",
}
}
}
*/
`
objects.postProcessFnc (
)parameters:
- schema (object) - Generated JSON schema
- obj - (object) - input value
- defaultFunc (function) - standard function that is used to post-process generated schema. Takes the
schema, obj params.By providing
postProcessFnc, you can modify or replace generated schema. This function
will be called recursively for all the properties and sub-properties and array items from leaves to the root of the obj object. Custom objects.postProcessFnc makes properties required on parent type level:
`javascript
const options = {
objects: {
postProcessFnc: (schema, obj, defaultFnc) => ({...defaultFnc(schema, obj), required: Object.getOwnPropertyNames(obj)})
}
};
const obj = {a: 1, b: 'str'};
const schema = toJsonSchema(obj, options);
/*
{
type: 'object',
properties: {
a: {type: 'integer'},
b: {type: 'string'},
}
required: ['a', 'b']
}
*/
`
$3
strings.preProcessFnc (
)By providing custom function you will be able to modify any string value (including nested ones) and pre-process
it before it gets converted to schema, modify generated schema or do the schema conversion entirely by yourself.
Provided function will receive two parameters:
-
string to be converted into JSON schema
- default function that normally generates the schema. This function receives only string to be converted to JSON schema Custom function from example bellow converts any string of object containing string to JSON schema and if string's content is 'date' than sets the format property to 'date':
`javascript
const options = {
strings: {
preProcessFnc: (value, defaultFnc) => {
const schema = defaultFnc(value);
if (value === 'date') {
schema.format = 'date';
}
return schema;
},
},
}
const schema = toJsonSchema('date', options);
/*
{
"type": "string",
"format": "date"
}
*/
`
strings.detectFormat ( default id true)When set to true format of the strings values may be detected based on it's content.
These JSON schema string formats can be detected:
* date-time
* date
* time
* utc-millisec
* color
* style
* phone
* uri
* email
* ip-address
* ipv6
`javascript
const obj = {
a: '2012-07-08T16:41:41.532Z',
b: '+31 42 123 4567',
c: 'http://www.google.com/',
d: 'obama@whitehouse.gov'
};
const schema = toJsonSchema(obj, {strings: {detectFormat: true}});
/*
{
"type": "object",
"properties": {
"a": {
"type": "string",
"format": "date-time"
},
"b": {
"type": "string",
"format": "phone"
},
"c": {
"type": "string",
"format": "uri"
},
"d": {
"type": "string",
"format": "email"
}
}
}
*/
``