Json schema validation against Json Object using javascript

Question

I am trying to validate around 100 JSON Objects against a JSON schema to see if all the fields along with the type are as per the schema or not.

Tried below JSON schema which was generated from a site. The issue with the below schema is that it does not support validation of multiple items for the "files" field as the schema is not completely correct.

Added below schema

     var schema ={
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "data": {
      "type": "object",
      "properties": {
        "contents": {
          "type": "array",
          "items": [
            {
              "type": "object",
              "properties": {
                "version": {
                  "type": "string"
                },
                "sequence": {
                  "type": "integer"
                },
                "files": {
                  "type": "array",
                  "items": [
                    {
                      "type": "object",
                      "properties": {
                        "fileName": {
                          "type": "string"
                        },
                        "name": {
                          "type": "string"
                        },
                        "fileSize": {
                          "type": "string"
                        },
                        "fileType": {
                          "type": "string"
                        },
                        "lastUpdatedDate": {
                          "type": "integer"
                        },
                        "fileLength": {
                          "type": "integer"
                        },
                        "version": {
                          "type": "integer"
                        }
                      },
                      "required": [
                        "fileName",
                        "name",
                        "fileSize",
                        "fileType",
                        "lastUpdatedDate",
                        "fileLength",
                        "version"
                      ]
                    }
                  ]
                }
              },
              "required": [
                "version",
                "sequence",
                "files"
              ]
            }
          ]
        }
      },
      "required": [
        "contents"
      ]
    }
  },
  "required": [
    "data"
  ]
}

  var validator = new Validator(schema)

  var json=
  {
      "data": {
          "contents": [
              {
                  "versionn": "2021-01-15T16:01:13.475Z",
                  "sequence": 1,
                  "files": [
                      {
                          "fileName": "us-producer-price-index.txt",
                          "name": "us-producer-price-index",
                          "fileSize": "54MB",
                          "fileType": "txt",
                          "lastUpdatedDate": 1610717473000,
                          "fileLength": 56614933,
                          "version": 2
                      }
                  ]
              }
          ]
      }
  };

  var check = validator.check(json);
   
  console.log(check);

  if(check._error==true)
  {
      console.log("Error in schema")
  }

@RichardRublev the schema is invalid? Could you please suggest the change — Suraj Prasad
– Suraj Prasad, Commented Feb 19, 2021 at 6:13

Bob · Accepted Answer · 2021-02-28 13:46:23Z

I assume that what you want is to apply the same validation rule for all the items in your array.

Schema provides list validation and tuple validation. The list validation is specified as a schema, apply the same rule for any item in the array, the tuple is specified as an array of schemas and validate item[i] against schema.item[i].

Notice that your items schemas is an array of one element. This means that only the first element is validated against your schema. What I assume you want instead is this schema.

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "data": {
      "type": "object",
      "properties": {
        "contents": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "version": {
                "type": "string"
              },
              "sequence": {
                "type": "integer"
              },
              "files": {
                "type": "array",
                "items": {
                  "type": "object",
                  "properties": {
                    "fileName": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string"
                    },
                    "fileSize": {
                      "type": "string"
                    },
                    "fileType": {
                      "type": "string"
                    },
                    "lastUpdatedDate": {
                      "type": "integer"
                    },
                    "fileLength": {
                      "type": "integer"
                    },
                    "version": {
                      "type": "integer"
                    }
                  },
                  "required": [
                    "fileName",
                    "name",
                    "fileSize",
                    "fileType",
                    "lastUpdatedDate",
                    "fileLength",
                    "version"
                  ]
                }
              }
            },
            "required": [
              "version",
              "sequence",
              "files"
            ]
          }
        }
      },
      "required": [
        "contents"
      ]
    }
  },
  "required": [
    "data"
  ]
}

Additional examples

In order to illustrate the how the array validation works I created a snipped that is very enlightening.

const Ajv = window.ajv7.default;
const ajv = new Ajv({strict: false});

function dumpJson(item){
  const el = document.createElement('pre');
  el.textContent = typeof(item) === 'string' ? item :  JSON.stringify(item)
  document.body.appendChild(el);
  return el;
}

function Test(schema, title){
  const validate = ajv.compile(schema)
  if(title)dumpJson(title).classList.add('title')
  dumpJson(JSON.stringify(schema, null, 2))
  const tester = {
    with: (item) => {
      const el = dumpJson(item)
      if(validate(item)){
        el.classList.add('valid');
      }else{
        el.classList.add('invalid');
      }
      return tester
    }
  }
  return tester;
}

Test({
  "$schema": "http://json-schema.org/draft-07/schema#",
  type: 'array', items: [{type: 'number'}, {type: 'string'}]
}, 'tuple validation: [number]')
.with([0])
.with([0, 1])
.with([0, "a"])
.with([0, "a", {}, [], null, false, true])
Test({
  "$schema": "http://json-schema.org/draft-07/schema#",
  type: 'array', items: [{type: 'number'}]
}, 'tuple validation: [number, string]')
.with([0])
.with([0, 1])
.with([0, "a"])
.with([0, "a", {}, [], null, false, true])

Test({
  "$schema": "http://json-schema.org/draft-07/schema#",
  type: 'array', items: {type: 'number'}
}, 'list validation: number[]')
.with([0])
.with([0, 1])
.with([0, "a"])
.with([0, "a", {}, [], null, false, true])


Test({
  "$schema": "http://json-schema.org/draft-07/schema#",
  type: 'array', items: [{type: 'number'}, {type: 'string'}]
}, 'tuple validation: [number, string]')
.with([0])
.with([0, 1])
.with([0, "a"])
.with([0, "a", {}, [], null, false, true])

Test({
  "$schema": "http://json-schema.org/draft-07/schema#",
  type: 'array', items: {'anyOf': [{type: 'number'}, {type: 'string'}]}
}, 'list validation: (number|string)[]')
.with([0])
.with([0, 1])
.with([0, "a"])
.with([0, "a", {}, [], null, false, true])
.with(['a', 'b', 'c'])
.with(['a', 0])
.with(['a', 0, false])

.valid {
  margin-left: 20px; color: green;
}
.invalid {
  margin-left: 20px; color: red;
}
.title {
  font-size: 2em;
}

body: {
  overflow: scroll;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/ajv/7.1.1/ajv7.min.js"></script>

Community · Accepted Answer · 2021-10-07 07:24:50Z

2

While your JSON Schema is "valid", it doesn't express any constraints.

you have missed the need to use the properties keyword.

The value of "properties" MUST be an object. Each value of this
object MUST be a valid JSON Schema.

Validation succeeds if, for each name that appears in both the
instance and as a name within this keyword's value, the child
instance for that name successfully validates against the
corresponding schema.

https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-02#section-9.3.2.1

In order to apply a subschema to an object, you need to use the properties keyword. Like this...

{
  "required": ["data"],
  "properties": {
    "data": {
      "type": "object"
    }
  }
}

This requirement applies for each subschema too. Unknown keywords are ignored, so data at the root of the schema was simply ignored, resulting in no constraints being expressed.

You may find it helpful to review the JSON Schema getting started guide: http://json-schema.org/learn/

Update: After adding an update to your question in the form of an answer, it looks like the generator is almost right, but not quite.

When using the items keyword pre draft 2020-12, array values apply subschemas items to the same index location only. If you want the subschema value to apply to all items in the applicable array, you need to use a schema object as the value as opposed to an array of schema values.

The value of "items" MUST be either a valid JSON Schema or an array
of valid JSON Schemas.

If "items" is a schema, validation succeeds if all elements in the array successfully validate against that schema.

If "items" is an array of schemas, validation succeeds if each
element of the instance validates against the schema at the same
position, if any.

JSON Schema draft 2019-09 - https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-02#section-9.3.1.1

I refer you to our getting started guide, as linked above, which covers this. If you expect to maintain your schemas, it would be worth reading.

edited Oct 7, 2021 at 7:24

CommunityBot

11 silver badge

answered Feb 19, 2021 at 10:18

Relequestual

12.4k7 gold badges52 silver badges87 bronze badges

11 Comments

Suraj Prasad Over a year ago

Thanks, I think you have my answer :) I did add the properties key too but it doesnt seem to make any change to the out. Request if you can add the schema for my json to help me understand. Thanks

Relequestual Over a year ago

If you have modified your schema and it still doesn't work, you should look at updating your question to ADD the new schema. If I can't see the full new schema, I'm not sure how to help you.

Suraj Prasad Over a year ago

I have now modified my question. Only confused on how handle properties for sub section of json

Relequestual Over a year ago

I can see you have updated your question. It looks like you didn't follow my suggestion of using the properties keyword. You've also posted your own answer, in which you can see how you need to use the properties keyword at each subschema where you want to apply subschemas to more property values. The schema generator you've used has resulted in a very old (draft-04) schema. If contents or files can have multiple items in the array values, then the schema is also wrong, and won't do what you want.

Suraj Prasad Over a year ago

I agree to your statement, could you please modify my schema so that files can handle multiple items in the array and I could mark your answer as the correct answer here. Would help a lot if you did. thanks

|

Collectives™ on Stack Overflow

Json schema validation against Json Object using javascript

2 Answers 2

Additional examples

Comments

11 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Additional examples

Comments

11 Comments

Your Answer

Sign up or log in

Post as a guest

Related