├── .github
    ├── FUNDING.yml
    └── workflows
    │   ├── build.yml
    │   └── publish.yml
├── spec
    ├── .eslintrc.yml
    ├── fixtures
    │   └── schema.js
    └── index.spec.js
├── .eslintrc.yml
├── index.d.ts
├── LICENSE
├── .gitignore
├── package.json
├── index.js
└── README.md


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: epoberezkin
2 | tidelift: "npm/json-schema-traverse"
3 | 


--------------------------------------------------------------------------------
/spec/.eslintrc.yml:
--------------------------------------------------------------------------------
1 | parserOptions:
2 |   ecmaVersion: 6
3 | globals:
4 |   beforeEach: false
5 |   describe: false
6 |   it: false
7 | 


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [master]
 6 |   pull_request:
 7 |     branches: ["*"]
 8 | 
 9 | jobs:
10 |   build:
11 |     runs-on: ubuntu-latest
12 | 
13 |     strategy:
14 |       matrix:
15 |         node-version: [10.x, 12.x, 14.x]
16 | 
17 |     steps:
18 |       - uses: actions/checkout@v2
19 |       - name: Use Node.js ${{ matrix.node-version }}
20 |         uses: actions/setup-node@v1
21 |         with:
22 |           node-version: ${{ matrix.node-version }}
23 |       - run: npm install
24 |       - run: npm test
25 |       - name: Coveralls
26 |         uses: coverallsapp/github-action@master
27 |         with:
28 |           github-token: ${{ secrets.GITHUB_TOKEN }}
29 | 


--------------------------------------------------------------------------------
/.eslintrc.yml:
--------------------------------------------------------------------------------
 1 | extends: eslint:recommended
 2 | env:
 3 |   node: true
 4 |   browser: true
 5 | rules:
 6 |   block-scoped-var: 2
 7 |   complexity: [2, 15]
 8 |   curly: [2, multi-or-nest, consistent]
 9 |   dot-location: [2, property]
10 |   dot-notation: 2
11 |   indent: [2, 2, SwitchCase: 1]
12 |   linebreak-style: [2, unix]
13 |   new-cap: 2
14 |   no-console: [2, allow: [warn, error]]
15 |   no-else-return: 2
16 |   no-eq-null: 2
17 |   no-fallthrough: 2
18 |   no-invalid-this: 2
19 |   no-return-assign: 2
20 |   no-shadow: 1
21 |   no-trailing-spaces: 2
22 |   no-use-before-define: [2, nofunc]
23 |   quotes: [2, single, avoid-escape]
24 |   semi: [2, always]
25 |   strict: [2, global]
26 |   valid-jsdoc: [2, requireReturn: false]
27 |   no-control-regex: 0
28 | 


--------------------------------------------------------------------------------
/.github/workflows/publish.yml:
--------------------------------------------------------------------------------
 1 | name: publish
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [published]
 6 | 
 7 | jobs:
 8 |   publish-npm:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: actions/checkout@v2
12 |       - uses: actions/setup-node@v1
13 |         with:
14 |           node-version: 14
15 |           registry-url: https://registry.npmjs.org/
16 |       - run: npm install
17 |       - run: npm test
18 |       - name: Publish beta version to npm
19 |         if: "github.event.release.prerelease"
20 |         run: npm publish --tag beta
21 |         env:
22 |           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
23 |       - name: Publish to npm
24 |         if: "!github.event.release.prerelease"
25 |         run: npm publish
26 |         env:
27 |           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
28 | 


--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
 1 | declare function traverse(
 2 |   schema: traverse.SchemaObject,
 3 |   opts: traverse.Options,
 4 |   cb?: traverse.Callback
 5 | ): void;
 6 | 
 7 | declare function traverse(
 8 |   schema: traverse.SchemaObject,
 9 |   cb: traverse.Callback
10 | ): void;
11 | 
12 | declare namespace traverse {
13 |   interface SchemaObject {
14 |     $id?: string;
15 |     $schema?: string;
16 |     [x: string]: any;
17 |   }
18 | 
19 |   type Callback = (
20 |     schema: SchemaObject,
21 |     jsonPtr: string,
22 |     rootSchema: SchemaObject,
23 |     parentJsonPtr?: string,
24 |     parentKeyword?: string,
25 |     parentSchema?: SchemaObject,
26 |     keyIndex?: string | number
27 |   ) => void;
28 | 
29 |   interface Options {
30 |     allKeys?: boolean;
31 |     cb?:
32 |       | Callback
33 |       | {
34 |           pre?: Callback;
35 |           post?: Callback;
36 |         };
37 |   }
38 | }
39 | 
40 | export = traverse;
41 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Evgeny Poberezkin
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | yarn-debug.log*
 6 | yarn-error.log*
 7 | 
 8 | # Runtime data
 9 | pids
10 | *.pid
11 | *.seed
12 | *.pid.lock
13 | 
14 | # Directory for instrumented libs generated by jscoverage/JSCover
15 | lib-cov
16 | 
17 | # Coverage directory used by tools like istanbul
18 | coverage
19 | 
20 | # nyc test coverage
21 | .nyc_output
22 | 
23 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
24 | .grunt
25 | 
26 | # Bower dependency directory (https://bower.io/)
27 | bower_components
28 | 
29 | # node-waf configuration
30 | .lock-wscript
31 | 
32 | # Compiled binary addons (http://nodejs.org/api/addons.html)
33 | build/Release
34 | 
35 | # Dependency directories
36 | node_modules/
37 | jspm_packages/
38 | 
39 | # Typescript v1 declaration files
40 | typings/
41 | 
42 | # Optional npm cache directory
43 | .npm
44 | 
45 | # Optional eslint cache
46 | .eslintcache
47 | 
48 | # Optional REPL history
49 | .node_repl_history
50 | 
51 | # Output of 'npm pack'
52 | *.tgz
53 | 
54 | # Yarn Integrity file
55 | .yarn-integrity
56 | 
57 | # dotenv environment variables file
58 | .env
59 | 
60 | .DS_Store
61 | 
62 | package-lock.json
63 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "json-schema-traverse",
 3 |   "version": "1.0.0",
 4 |   "description": "Traverse JSON Schema passing each schema object to callback",
 5 |   "main": "index.js",
 6 |   "types": "index.d.ts",
 7 |   "files":[
 8 |     "index.d.ts"
 9 |   ],
10 |   "scripts": {
11 |     "eslint": "eslint index.js spec",
12 |     "test-spec": "mocha spec -R spec",
13 |     "test": "npm run eslint && nyc npm run test-spec"
14 |   },
15 |   "repository": {
16 |     "type": "git",
17 |     "url": "git+https://github.com/epoberezkin/json-schema-traverse.git"
18 |   },
19 |   "keywords": [
20 |     "JSON-Schema",
21 |     "traverse",
22 |     "iterate"
23 |   ],
24 |   "author": "Evgeny Poberezkin",
25 |   "license": "MIT",
26 |   "bugs": {
27 |     "url": "https://github.com/epoberezkin/json-schema-traverse/issues"
28 |   },
29 |   "homepage": "https://github.com/epoberezkin/json-schema-traverse#readme",
30 |   "devDependencies": {
31 |     "eslint": "^7.3.1",
32 |     "mocha": "^8.0.1",
33 |     "nyc": "^15.0.0",
34 |     "pre-commit": "^1.2.2"
35 |   },
36 |   "nyc": {
37 |     "exclude": [
38 |       "**/spec/**",
39 |       "node_modules"
40 |     ],
41 |     "reporter": [
42 |       "lcov",
43 |       "text-summary"
44 |     ]
45 |   }
46 | }
47 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | var traverse = module.exports = function (schema, opts, cb) {
 4 |   // Legacy support for v0.3.1 and earlier.
 5 |   if (typeof opts == 'function') {
 6 |     cb = opts;
 7 |     opts = {};
 8 |   }
 9 | 
10 |   cb = opts.cb || cb;
11 |   var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};
12 |   var post = cb.post || function() {};
13 | 
14 |   _traverse(opts, pre, post, schema, '', schema);
15 | };
16 | 
17 | 
18 | traverse.keywords = {
19 |   additionalItems: true,
20 |   items: true,
21 |   contains: true,
22 |   additionalProperties: true,
23 |   propertyNames: true,
24 |   not: true,
25 |   if: true,
26 |   then: true,
27 |   else: true
28 | };
29 | 
30 | traverse.arrayKeywords = {
31 |   items: true,
32 |   allOf: true,
33 |   anyOf: true,
34 |   oneOf: true
35 | };
36 | 
37 | traverse.propsKeywords = {
38 |   $defs: true,
39 |   definitions: true,
40 |   properties: true,
41 |   patternProperties: true,
42 |   dependencies: true
43 | };
44 | 
45 | traverse.skipKeywords = {
46 |   default: true,
47 |   enum: true,
48 |   const: true,
49 |   required: true,
50 |   maximum: true,
51 |   minimum: true,
52 |   exclusiveMaximum: true,
53 |   exclusiveMinimum: true,
54 |   multipleOf: true,
55 |   maxLength: true,
56 |   minLength: true,
57 |   pattern: true,
58 |   format: true,
59 |   maxItems: true,
60 |   minItems: true,
61 |   uniqueItems: true,
62 |   maxProperties: true,
63 |   minProperties: true
64 | };
65 | 
66 | 
67 | function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
68 |   if (schema && typeof schema == 'object' && !Array.isArray(schema)) {
69 |     pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
70 |     for (var key in schema) {
71 |       var sch = schema[key];
72 |       if (Array.isArray(sch)) {
73 |         if (key in traverse.arrayKeywords) {
74 |           for (var i=0; i<sch.length; i++)
75 |             _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);
76 |         }
77 |       } else if (key in traverse.propsKeywords) {
78 |         if (sch && typeof sch == 'object') {
79 |           for (var prop in sch)
80 |             _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
81 |         }
82 |       } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {
83 |         _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);
84 |       }
85 |     }
86 |     post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
87 |   }
88 | }
89 | 
90 | 
91 | function escapeJsonPtr(str) {
92 |   return str.replace(/~/g, '~0').replace(/\//g, '~1');
93 | }
94 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # json-schema-traverse
 2 | Traverse JSON Schema passing each schema object to callback
 3 | 
 4 | [![build](https://github.com/epoberezkin/json-schema-traverse/workflows/build/badge.svg)](https://github.com/epoberezkin/json-schema-traverse/actions?query=workflow%3Abuild)
 5 | [![npm](https://img.shields.io/npm/v/json-schema-traverse)](https://www.npmjs.com/package/json-schema-traverse)
 6 | [![coverage](https://coveralls.io/repos/github/epoberezkin/json-schema-traverse/badge.svg?branch=master)](https://coveralls.io/github/epoberezkin/json-schema-traverse?branch=master)
 7 | 
 8 | 
 9 | ## Install
10 | 
11 | ```
12 | npm install json-schema-traverse
13 | ```
14 | 
15 | 
16 | ## Usage
17 | 
18 | ```javascript
19 | const traverse = require('json-schema-traverse');
20 | const schema = {
21 |   properties: {
22 |     foo: {type: 'string'},
23 |     bar: {type: 'integer'}
24 |   }
25 | };
26 | 
27 | traverse(schema, {cb});
28 | // cb is called 3 times with:
29 | // 1. root schema
30 | // 2. {type: 'string'}
31 | // 3. {type: 'integer'}
32 | 
33 | // Or:
34 | 
35 | traverse(schema, {cb: {pre, post}});
36 | // pre is called 3 times with:
37 | // 1. root schema
38 | // 2. {type: 'string'}
39 | // 3. {type: 'integer'}
40 | //
41 | // post is called 3 times with:
42 | // 1. {type: 'string'}
43 | // 2. {type: 'integer'}
44 | // 3. root schema
45 | 
46 | ```
47 | 
48 | Callback function `cb` is called for each schema object (not including draft-06 boolean schemas), including the root schema, in pre-order traversal. Schema references ($ref) are not resolved, they are passed as is.  Alternatively, you can pass a `{pre, post}` object as `cb`, and then `pre` will be called before traversing child elements, and `post` will be called after all child elements have been traversed.
49 | 
50 | Callback is passed these parameters:
51 | 
52 | - _schema_: the current schema object
53 | - _JSON pointer_: from the root schema to the current schema object
54 | - _root schema_: the schema passed to `traverse` object
55 | - _parent JSON pointer_: from the root schema to the parent schema object (see below)
56 | - _parent keyword_: the keyword inside which this schema appears (e.g. `properties`, `anyOf`, etc.)
57 | - _parent schema_: not necessarily parent object/array; in the example above the parent schema for `{type: 'string'}` is the root schema
58 | - _index/property_: index or property name in the array/object containing multiple schemas; in the example above for `{type: 'string'}` the property name is `'foo'`
59 | 
60 | 
61 | ## Traverse objects in all unknown keywords
62 | 
63 | ```javascript
64 | const traverse = require('json-schema-traverse');
65 | const schema = {
66 |   mySchema: {
67 |     minimum: 1,
68 |     maximum: 2
69 |   }
70 | };
71 | 
72 | traverse(schema, {allKeys: true, cb});
73 | // cb is called 2 times with:
74 | // 1. root schema
75 | // 2. mySchema
76 | ```
77 | 
78 | Without option `allKeys: true` callback will be called only with root schema.
79 | 
80 | 
81 | ## Enterprise support
82 | 
83 | json-schema-traverse package is a part of [Tidelift enterprise subscription](https://tidelift.com/subscription/pkg/npm-json-schema-traverse?utm_source=npm-json-schema-traverse&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) - it provides a centralised commercial support to open-source software users, in addition to the support provided by software maintainers.
84 | 
85 | 
86 | ## Security contact
87 | 
88 | To report a security vulnerability, please use the
89 | [Tidelift security contact](https://tidelift.com/security).
90 | Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerability via GitHub issues.
91 | 
92 | 
93 | ## License
94 | 
95 | [MIT](https://github.com/epoberezkin/json-schema-traverse/blob/master/LICENSE)
96 | 


--------------------------------------------------------------------------------
/spec/fixtures/schema.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | var schema = {
  4 |   additionalItems: subschema('additionalItems'),
  5 |   items: subschema('items'),
  6 |   contains: subschema('contains'),
  7 |   additionalProperties: subschema('additionalProperties'),
  8 |   propertyNames: subschema('propertyNames'),
  9 |   not: subschema('not'),
 10 |   allOf: [
 11 |     subschema('allOf_0'),
 12 |     subschema('allOf_1'),
 13 |     {
 14 |       items: [
 15 |         subschema('items_0'),
 16 |         subschema('items_1'),
 17 |       ]
 18 |     }
 19 |   ],
 20 |   anyOf: [
 21 |     subschema('anyOf_0'),
 22 |     subschema('anyOf_1'),
 23 |   ],
 24 |   oneOf: [
 25 |     subschema('oneOf_0'),
 26 |     subschema('oneOf_1'),
 27 |   ],
 28 |   definitions: {
 29 |     foo: subschema('definitions_foo'),
 30 |     bar: subschema('definitions_bar'),
 31 |   },
 32 |   properties: {
 33 |     foo: subschema('properties_foo'),
 34 |     bar: subschema('properties_bar'),
 35 |   },
 36 |   patternProperties: {
 37 |     foo: subschema('patternProperties_foo'),
 38 |     bar: subschema('patternProperties_bar'),
 39 |   },
 40 |   dependencies: {
 41 |     foo: subschema('dependencies_foo'),
 42 |     bar: subschema('dependencies_bar'),
 43 |   },
 44 |   required: ['foo', 'bar']
 45 | };
 46 | 
 47 | 
 48 | function subschema(keyword) {
 49 |   var sch = {
 50 |     properties: {},
 51 |     additionalProperties: false,
 52 |     additionalItems: false,
 53 |     anyOf: [
 54 |       {format: 'email'},
 55 |       {format: 'hostname'}
 56 |     ]
 57 |   };
 58 |   sch.properties['foo_' + keyword] = {title: 'foo'};
 59 |   sch.properties['bar_' + keyword] = {title: 'bar'};
 60 |   return sch;
 61 | }
 62 | 
 63 | 
 64 | module.exports = {
 65 |   schema: schema,
 66 | 
 67 |   // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
 68 |   expectedCalls: [[schema, '', schema, undefined, undefined, undefined, undefined]]
 69 |     .concat(expectedCalls('additionalItems'))
 70 |     .concat(expectedCalls('items'))
 71 |     .concat(expectedCalls('contains'))
 72 |     .concat(expectedCalls('additionalProperties'))
 73 |     .concat(expectedCalls('propertyNames'))
 74 |     .concat(expectedCalls('not'))
 75 |     .concat(expectedCallsChild('allOf', 0))
 76 |     .concat(expectedCallsChild('allOf', 1))
 77 |     .concat([
 78 |       [schema.allOf[2], '/allOf/2', schema, '', 'allOf', schema, 2],
 79 |       [schema.allOf[2].items[0], '/allOf/2/items/0', schema, '/allOf/2', 'items', schema.allOf[2], 0],
 80 |       [schema.allOf[2].items[0].properties.foo_items_0, '/allOf/2/items/0/properties/foo_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'foo_items_0'],
 81 |       [schema.allOf[2].items[0].properties.bar_items_0, '/allOf/2/items/0/properties/bar_items_0', schema, '/allOf/2/items/0', 'properties', schema.allOf[2].items[0], 'bar_items_0'],
 82 |       [schema.allOf[2].items[0].anyOf[0], '/allOf/2/items/0/anyOf/0', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 0],
 83 |       [schema.allOf[2].items[0].anyOf[1], '/allOf/2/items/0/anyOf/1', schema, '/allOf/2/items/0', 'anyOf', schema.allOf[2].items[0], 1],
 84 | 
 85 |       [schema.allOf[2].items[1], '/allOf/2/items/1', schema, '/allOf/2', 'items', schema.allOf[2], 1],
 86 |       [schema.allOf[2].items[1].properties.foo_items_1, '/allOf/2/items/1/properties/foo_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'foo_items_1'],
 87 |       [schema.allOf[2].items[1].properties.bar_items_1, '/allOf/2/items/1/properties/bar_items_1', schema, '/allOf/2/items/1', 'properties', schema.allOf[2].items[1], 'bar_items_1'],
 88 |       [schema.allOf[2].items[1].anyOf[0], '/allOf/2/items/1/anyOf/0', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 0],
 89 |       [schema.allOf[2].items[1].anyOf[1], '/allOf/2/items/1/anyOf/1', schema, '/allOf/2/items/1', 'anyOf', schema.allOf[2].items[1], 1]
 90 |     ])
 91 |     .concat(expectedCallsChild('anyOf', 0))
 92 |     .concat(expectedCallsChild('anyOf', 1))
 93 |     .concat(expectedCallsChild('oneOf', 0))
 94 |     .concat(expectedCallsChild('oneOf', 1))
 95 |     .concat(expectedCallsChild('definitions', 'foo'))
 96 |     .concat(expectedCallsChild('definitions', 'bar'))
 97 |     .concat(expectedCallsChild('properties', 'foo'))
 98 |     .concat(expectedCallsChild('properties', 'bar'))
 99 |     .concat(expectedCallsChild('patternProperties', 'foo'))
100 |     .concat(expectedCallsChild('patternProperties', 'bar'))
101 |     .concat(expectedCallsChild('dependencies', 'foo'))
102 |     .concat(expectedCallsChild('dependencies', 'bar'))
103 | };
104 | 
105 | 
106 | function expectedCalls(keyword) {
107 |   return [
108 |     [schema[keyword], `/${keyword}`, schema, '', keyword, schema, undefined],
109 |     [schema[keyword].properties[`foo_${keyword}`], `/${keyword}/properties/foo_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `foo_${keyword}`],
110 |     [schema[keyword].properties[`bar_${keyword}`], `/${keyword}/properties/bar_${keyword}`, schema, `/${keyword}`, 'properties', schema[keyword], `bar_${keyword}`],
111 |     [schema[keyword].anyOf[0], `/${keyword}/anyOf/0`, schema, `/${keyword}`, 'anyOf', schema[keyword], 0],
112 |     [schema[keyword].anyOf[1], `/${keyword}/anyOf/1`, schema, `/${keyword}`, 'anyOf', schema[keyword], 1]
113 |   ];
114 | }
115 | 
116 | 
117 | function expectedCallsChild(keyword, i) {
118 |   return [
119 |     [schema[keyword][i], `/${keyword}/${i}`, schema, '', keyword, schema, i],
120 |     [schema[keyword][i].properties[`foo_${keyword}_${i}`], `/${keyword}/${i}/properties/foo_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `foo_${keyword}_${i}`],
121 |     [schema[keyword][i].properties[`bar_${keyword}_${i}`], `/${keyword}/${i}/properties/bar_${keyword}_${i}`, schema, `/${keyword}/${i}`, 'properties', schema[keyword][i], `bar_${keyword}_${i}`],
122 |     [schema[keyword][i].anyOf[0], `/${keyword}/${i}/anyOf/0`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 0],
123 |     [schema[keyword][i].anyOf[1], `/${keyword}/${i}/anyOf/1`, schema, `/${keyword}/${i}`, 'anyOf', schema[keyword][i], 1]
124 |   ];
125 | }
126 | 


--------------------------------------------------------------------------------
/spec/index.spec.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | var traverse = require('../index');
  4 | var assert = require('assert');
  5 | 
  6 | describe('json-schema-traverse', function() {
  7 |   var calls;
  8 | 
  9 |   beforeEach(function() {
 10 |     calls = [];
 11 |   });
 12 | 
 13 |   it('should traverse all keywords containing schemas recursively', function() {
 14 |     var schema = require('./fixtures/schema').schema;
 15 |     var expectedCalls = require('./fixtures/schema').expectedCalls;
 16 | 
 17 |     traverse(schema, {cb: callback});
 18 |     assert.deepStrictEqual(calls, expectedCalls);
 19 |   });
 20 | 
 21 |   describe('Legacy v0.3.1 API', function() {
 22 |     it('should traverse all keywords containing schemas recursively', function() {
 23 |       var schema = require('./fixtures/schema').schema;
 24 |       var expectedCalls = require('./fixtures/schema').expectedCalls;
 25 | 
 26 |       traverse(schema, callback);
 27 |       assert.deepStrictEqual(calls, expectedCalls);
 28 |     });
 29 | 
 30 |     it('should work when an options object is provided', function() {
 31 |       // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
 32 |       var schema = require('./fixtures/schema').schema;
 33 |       var expectedCalls = require('./fixtures/schema').expectedCalls;
 34 | 
 35 |       traverse(schema, {}, callback);
 36 |       assert.deepStrictEqual(calls, expectedCalls);
 37 |     });
 38 |   });
 39 | 
 40 | 
 41 |   describe('allKeys option', function() {
 42 |     var schema = {
 43 |       someObject: {
 44 |         minimum: 1,
 45 |         maximum: 2
 46 |       }
 47 |     };
 48 | 
 49 |     it('should traverse objects with allKeys: true option', function() {
 50 |       // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
 51 |       var expectedCalls = [
 52 |         [schema, '', schema, undefined, undefined, undefined, undefined],
 53 |         [schema.someObject, '/someObject', schema, '', 'someObject', schema, undefined]
 54 |       ];
 55 | 
 56 |       traverse(schema, {allKeys: true, cb: callback});
 57 |       assert.deepStrictEqual(calls, expectedCalls);
 58 |     });
 59 | 
 60 | 
 61 |     it('should NOT traverse objects with allKeys: false option', function() {
 62 |       // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
 63 |       var expectedCalls = [
 64 |         [schema, '', schema, undefined, undefined, undefined, undefined]
 65 |       ];
 66 | 
 67 |       traverse(schema, {allKeys: false, cb: callback});
 68 |       assert.deepStrictEqual(calls, expectedCalls);
 69 |     });
 70 | 
 71 | 
 72 |     it('should NOT traverse objects without allKeys option', function() {
 73 |       // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
 74 |       var expectedCalls = [
 75 |         [schema, '', schema, undefined, undefined, undefined, undefined]
 76 |       ];
 77 | 
 78 |       traverse(schema, {cb: callback});
 79 |       assert.deepStrictEqual(calls, expectedCalls);
 80 |     });
 81 | 
 82 | 
 83 |     it('should NOT travers objects in standard keywords which value is not a schema', function() {
 84 |       var schema2 = {
 85 |         const: {foo: 'bar'},
 86 |         enum: ['a', 'b'],
 87 |         required: ['foo'],
 88 |         another: {
 89 | 
 90 |         },
 91 |         patternProperties: {}, // will not traverse - no properties
 92 |         dependencies: true, // will not traverse - invalid
 93 |         properties: {
 94 |           smaller: {
 95 |             type: 'number'
 96 |           },
 97 |           larger: {
 98 |             type: 'number',
 99 |             minimum: {$data: '1/smaller'}
100 |           }
101 |         }
102 |       };
103 | 
104 |       // schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex
105 |       var expectedCalls = [
106 |         [schema2, '', schema2, undefined, undefined, undefined, undefined],
107 |         [schema2.another, '/another', schema2, '', 'another', schema2, undefined],
108 |         [schema2.properties.smaller, '/properties/smaller', schema2, '', 'properties', schema2, 'smaller'],
109 |         [schema2.properties.larger, '/properties/larger', schema2, '', 'properties', schema2, 'larger'],
110 |       ];
111 | 
112 |       traverse(schema2, {allKeys: true, cb: callback});
113 |       assert.deepStrictEqual(calls, expectedCalls);
114 |     });
115 |   });
116 | 
117 |   describe('pre and post', function() {
118 |     var schema = {
119 |       type: 'object',
120 |       properties: {
121 |         name: {type: 'string'},
122 |         age: {type: 'number'}
123 |       }
124 |     };
125 | 
126 |     it('should traverse schema in pre-order', function() {
127 |       traverse(schema, {cb: {pre}});
128 |       var expectedCalls = [
129 |         ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
130 |         ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
131 |         ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
132 |       ];
133 |       assert.deepStrictEqual(calls, expectedCalls);
134 |     });
135 | 
136 |     it('should traverse schema in post-order', function() {
137 |       traverse(schema, {cb: {post}});
138 |       var expectedCalls = [
139 |         ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
140 |         ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
141 |         ['post', schema, '', schema, undefined, undefined, undefined, undefined],
142 |       ];
143 |       assert.deepStrictEqual(calls, expectedCalls);
144 |     });
145 | 
146 |     it('should traverse schema in pre- and post-order at the same time', function() {
147 |       traverse(schema, {cb: {pre, post}});
148 |       var expectedCalls = [
149 |         ['pre', schema, '', schema, undefined, undefined, undefined, undefined],
150 |         ['pre', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
151 |         ['post', schema.properties.name, '/properties/name', schema, '', 'properties', schema, 'name'],
152 |         ['pre', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
153 |         ['post', schema.properties.age, '/properties/age', schema, '', 'properties', schema, 'age'],
154 |         ['post', schema, '', schema, undefined, undefined, undefined, undefined],
155 |       ];
156 |       assert.deepStrictEqual(calls, expectedCalls);
157 |     });
158 |   });
159 | 
160 |   function callback() {
161 |     calls.push(Array.prototype.slice.call(arguments));
162 |   }
163 | 
164 |   function pre() {
165 |     calls.push(['pre'].concat(Array.prototype.slice.call(arguments)));
166 |   }
167 | 
168 |   function post() {
169 |     calls.push(['post'].concat(Array.prototype.slice.call(arguments)));
170 |   }
171 | });
172 | 


--------------------------------------------------------------------------------