docs, fix: deepRequired keyword

Author: epoberezkin

README.md

@@ -18,6 +18,7 @@ Custom JSON-Schema keywords for [ajv](https://github.com/epoberezkin/ajv) valida
   - [range and exclusiveRange](#range-and-exclusiverange)
   - [propertyNames](#propertynames)
   - [if/then/else](#ifthenelse)
+  - [deepRequired](#deeprequired)
   - [regexp](#regexp)
   - [dynamicDefaults](#dynamicdefaults)
 - [License](#license)
@@ -168,6 +169,8 @@ These keywords allow to implement conditional validation. Their values should be
 If the data is valid according to the sub-schema in `if` keyword, then the result is equal to the result of data validation against the sub-schema in `then` keyword, otherwise - in `else` keyword (if `else` is absent, the validation succeeds).
 
 ```javascript
+require('ajv-keywords')(ajv, 'if');
+
 var schema = {
   type: 'array',
   items: {
@@ -182,11 +185,47 @@ var schema = {
 var validItems = [ 2, 4, 6, 8, 10, 15, 20, 25 ]; // etc.
 
 var invalidItems = [ 1, 3, 5, 11, 12 ]; // etc.
+
+ajv.validate(schema, validItems); // true
+ajv.validate(schema, invalidItems); // false
 ```
 
 This keyword is [proposed](https://github.com/json-schema-org/json-schema-spec/issues/180) for the future version of JSON-Schema standard.
 
 
+### `deepRequired`
+
+This keyword allows to check that some deep properties (identified by JSON pointers) are available. The value should be an array of JSON pointers to the data, starting from the current position in data.
+
+```javascript
+var schema = {
+  type: 'object',
+  deepRequired: ["users/1/role"]
+};
+
+var validData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: 'admin'
+    }
+  ]
+};
+
+var invalidData = {
+  users: [
+    {},
+    {
+      id: 123
+    }
+  ]
+};
+```
+
+See [json-schema-org/json-schema-spec#203](https://github.com/json-schema-org/json-schema-spec/issues/203#issue-197211916) for an example of the equivalent schema without `deepRequired` keyword.
+
+
 ### `regexp`
 
 This keyword allows to use regular expressions with flags in schemas (the standard `pattern` keyword does not support flags). The value of this keyword can be either a string (the result of `regexp.toString()`) or an object with the properties `pattern` and `flags` (the same strings that should be passed to RegExp constructor).

keywords/deepRequired.js

@@ -7,7 +7,7 @@ module.exports = function defFunc(ajv) {
       var expr = '';
       for (var i=0; i<schema.length; i++) {
         if (i) expr += ' && ';
-        expr += '(' + getData(schema[i], it.dataLvl) + ' !== undefined)';
+        expr += '(' + getData(schema[i], it.dataLevel) + ' !== undefined)';
       }
       return expr;
     }
@@ -24,12 +24,10 @@ function getData(jsonPointer, lvl) {
 
   var expr = data;
   var segments = jsonPointer.split('/');
-  for (var i=0; i<segments.length; i++) {
+  for (var i=1; i<segments.length; i++) {
     var segment = segments[i];
-    if (segment) {
-      data += getProperty(unescapeJsonPointer(segment));
-      expr += ' && ' + data;
-    }
+    data += getProperty(unescapeJsonPointer(segment));
+    expr += ' && ' + data;
   }
   return expr;
 }

spec/tests/deepRequired.json

@@ -47,48 +47,130 @@
     "description": "deepRequired keyword with items",
     "schema": {
       "type": "object",
-      "deepRequired": [ "/foo/1/bar", "/foo/2/baz", "/quux/3" ]
+      "properties": {
+        "inside": {
+          "type": "object",
+          "deepRequired": [ "/foo/1/bar", "/foo/2/baz", "/quux/3" ]
+        }
+      }
     },
     "tests": [
       {
         "description": "object with all required properties/items is valid",
         "data": {
-          "foo": [
-            {},
-            { "bar": 1 },
-            { "baz": 2 }
-          ],
-          "quux": [ 0, 1, 2, 3 ]
+          "inside": {
+            "foo": [
+              {},
+              { "bar": 1 },
+              { "baz": 2 }
+            ],
+            "quux": [ 0, 1, 2, 3 ]
+          }
         },
         "valid": true
       },
       {
         "description": "object without any required properties is invalid",
         "data": {
-          "foo": [{}, {}, {}],
-          "quux": [0, 1, 2]
+          "inside": {
+            "foo": [{}, {}, {}],
+            "quux": [0, 1, 2]
+          }
         },
         "valid": false
       },
       {
         "description": "object with one required property is invalid",
         "data": {
-          "quux": [ 0, 1, 2, 3 ]
+          "inside": {
+            "quux": [ 0, 1, 2, 3 ]
+          }
         },
         "valid": false
       },
       {
         "description": "object with one required sub-property is invalid",
         "data": {
-          "foo": [
-            {},
-            { "bar": 1 },
-            {}
-          ],
-          "quux": [ 0, 1, 2, 3 ]
+          "inside": {
+            "foo": [
+              {},
+              { "bar": 1 },
+              {}
+            ],
+            "quux": [ 0, 1, 2, 3 ]
+          }
         },
         "valid": false
       }
     ]
+  },
+  {
+    "description": "deepRequired keyword with empty sub-properties",
+    "schema": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "deepRequired": [ "/", "/foo/", "/bar//baz" ]
+      }
+    },
+    "tests": [
+      {
+        "description": "object with required properties is valid",
+        "data": [
+          {
+            "": 0,
+            "foo": {
+              "": 1
+            },
+            "bar": {
+              "": {
+                "baz": 2
+              }
+            }
+          }
+        ],
+        "valid": true
+      },
+      {
+        "description": "object without any required properties is invalid",
+        "data": [
+          {
+            "foo": {},
+            "bar": {
+              "": {}
+            }
+          }
+        ],
+        "valid": false
+      },
+      {
+        "description": "object with one required property is invalid",
+        "data": [
+          {
+            "": 0,
+            "foo": {},
+            "bar": {
+              "": {}
+            }
+          }
+        ],
+        "valid": false
+      },
+      {
+        "description": "object with one required sub-property is invalid",
+        "data": [
+          {
+            "": 0,
+            "foo": {
+              "": 1
+            },
+            "bar": {
+              "": {}
+            }
+          }
+        ],
+        "valid": false
+      }
+    ]
   }
 ]