Merge branch 'master' into fix/increase-test-coverage-for-bfs-and-cycles

Author: BelfordZ

CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.11.0](https://github.com/json-schema-tools/traverse/compare/1.10.4...1.11.0) (2025-06-20)
+
+
+### Features
+
+* support additional schema keywords ([6c0a7fa](https://github.com/json-schema-tools/traverse/commit/6c0a7fa714a2640ba6da7bfa3f2597ff42ffe71c))
+
 ## [1.10.4](https://github.com/json-schema-tools/traverse/compare/1.10.3...1.10.4) (2024-05-07)
 
 

README.md

@@ -54,16 +54,29 @@ traverse(mySchema, (schemaOrSubschema) => {
 });
 ```
 
-## API Docs
+### Advanced Options
+
+`traverse` accepts an optional options object as the third argument. Some useful
+flags include:
 
-https://json-schema-tools.github.io/traverse/
+- `bfs` - process schemas in a breadth first order
+- `skipFirstMutation` - do not call the mutation function on the root schema
+- `mergeNotMutate` - merge the mutation result back into the original schema
 
-## Features Todo
+```js
+traverse(mySchema, (schemaOrSubschema) => {
+  console.log(schemaOrSubschema.title);
+}, {
+  bfs: true,
+  skipFirstMutation: true,
+  mergeNotMutate: true,
+});
+```
+
+## API Docs
 
- - unevaluatedItems (https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.9.3.1.3)
- - unevaluatedProperties (https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.9.3.2.4)
- - contains (https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.9.3.1.4)
- - propertyNames (https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.section.9.3.2.5)
+The full TypeDoc generated API documentation is available at
+[https://json-schema-tools.github.io/traverse/](https://json-schema-tools.github.io/traverse/).
 
 ### Contributing
 

src/index.test.ts

@@ -622,6 +622,109 @@ describe("traverse", () => {
     });
   });
 
+    it("traverses contains", () => {
+      const testSchema: any = {
+        contains: { type: "string" }
+      };
+      const mockMutation = jest.fn((mockS) => mockS);
+
+      traverse(testSchema, mockMutation);
+
+      expect(mockMutation).nthCalledWith(
+        1,
+        testSchema.contains,
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+      );
+      expect(mockMutation).nthCalledWith(
+        2,
+        testSchema,
+        expect.anything(),
+        expect.anything(),
+        undefined,
+      );
+
+      expect(mockMutation).toHaveBeenCalledTimes(2);
+    });
+
+    it("traverses propertyNames", () => {
+      const testSchema: any = {
+        propertyNames: { type: "string" }
+      };
+      const mockMutation = jest.fn((mockS) => mockS);
+
+      traverse(testSchema, mockMutation);
+
+      expect(mockMutation).nthCalledWith(
+        1,
+        testSchema.propertyNames,
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+      );
+      expect(mockMutation).nthCalledWith(
+        2,
+        testSchema,
+        expect.anything(),
+        expect.anything(),
+        undefined,
+      );
+
+      expect(mockMutation).toHaveBeenCalledTimes(2);
+    });
+
+    it("traverses unevaluatedItems as boolean", () => {
+      const testSchema: any = {
+        unevaluatedItems: false,
+      };
+      const mockMutation = jest.fn((mockS) => mockS);
+
+      traverse(testSchema, mockMutation);
+
+      expect(mockMutation).nthCalledWith(
+        1,
+        testSchema.unevaluatedItems,
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+      );
+      expect(mockMutation).nthCalledWith(
+        2,
+        testSchema,
+        expect.anything(),
+        expect.anything(),
+        undefined,
+      );
+
+      expect(mockMutation).toHaveBeenCalledTimes(2);
+    });
+
+    it("traverses unevaluatedProperties as schema", () => {
+      const testSchema: any = {
+        unevaluatedProperties: { type: "string" },
+      };
+      const mockMutation = jest.fn((mockS) => mockS);
+
+      traverse(testSchema, mockMutation);
+
+      expect(mockMutation).nthCalledWith(
+        1,
+        testSchema.unevaluatedProperties,
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+      );
+      expect(mockMutation).nthCalledWith(
+        2,
+        testSchema,
+        expect.anything(),
+        expect.anything(),
+        undefined,
+      );
+
+    expect(mockMutation).toHaveBeenCalledTimes(2);
+  });
 
   describe("schema.type being an array", () => {
     it("allows type to be an array", () => {
@@ -1092,8 +1195,6 @@ describe("traverse", () => {
       );
     });
   });
-});
-
 describe("Mutability settings", () => {
   it("defaults to being immutable", () => {
     const s = {
@@ -1266,3 +1367,4 @@ describe("Mutability settings", () => {
     });
   });
 });
+});

src/index.ts

@@ -1,4 +1,5 @@
 import { JSONSchema, JSONSchemaObject, PatternProperties } from "@json-schema-tools/meta-schema";
+import { jsonPathStringify, isCycle, last } from "./utils";
 
 /**
  * Signature of the mutation method passed to traverse.
@@ -49,28 +50,6 @@ export const defaultOptions: TraverseOptions = {
   bfs: false,
 };
 
-const jsonPathStringify = (s: string[]) => {
-  return s.map((i) => {
-    if (i === "") {
-      return '$';
-    } else {
-      return `.${i}`;
-    }
-  }).join("");
-};
-
-const isCycle = (s: JSONSchema, recursiveStack: JSONSchema[]): JSONSchema | false => {
-  const foundInRecursiveStack = recursiveStack.find((recSchema) => recSchema === s);
-  if (foundInRecursiveStack) {
-    return foundInRecursiveStack;
-  }
-  return false;
-};
-
-const last = (i: JSONSchema[], skip = 1): JSONSchema => {
-  return i[i.length - skip];
-};
-
 /**
  * Traverse all subschema of a schema, calling the mutator function with each.
  * The mutator is called on leaf nodes first.
@@ -238,6 +217,20 @@ export default function traverse(
       );
     }
 
+    if (schema.contains !== undefined) {
+      mutableSchema.contains = rec(
+        schema.contains,
+        [...pathStack, "contains"],
+      );
+    }
+
+    if (schema.unevaluatedItems !== undefined) {
+      mutableSchema.unevaluatedItems = rec(
+        schema.unevaluatedItems,
+        [...pathStack, "unevaluatedItems"],
+      );
+    }
+
     if (schema.properties !== undefined) {
       const sProps: { [key: string]: JSONSchema } = schema.properties;
       const mutableProps: { [key: string]: JSONSchema } = {};
@@ -263,6 +256,20 @@ export default function traverse(
     if (schema.additionalProperties !== undefined && !!schema.additionalProperties === true) {
       mutableSchema.additionalProperties = rec(schema.additionalProperties, [...pathStack, "additionalProperties"]);
     }
+
+    if (schema.propertyNames !== undefined) {
+      mutableSchema.propertyNames = rec(
+        schema.propertyNames,
+        [...pathStack, "propertyNames"],
+      );
+    }
+
+    if (schema.unevaluatedProperties !== undefined && !!schema.unevaluatedProperties === true) {
+      mutableSchema.unevaluatedProperties = rec(
+        schema.unevaluatedProperties,
+        [...pathStack, "unevaluatedProperties"],
+      );
+    }
   }
 
   if (opts.skipFirstMutation === true && depth === 0) {
@@ -273,11 +280,11 @@ export default function traverse(
     mutableStack.pop();
     return mutableSchema;
   } else {
-    const isCycle = cycleSet.indexOf(schema) !== -1
+    const isCycleNode = cycleSet.indexOf(schema) !== -1
     mutableStack.pop();
     return mutation(
       mutableSchema,
-      isCycle,
+      isCycleNode,
       jsonPathStringify(pathStack),
       last(mutableStack)
     );

src/utils.ts

@@ -0,0 +1,28 @@
+import { JSONSchema } from "@json-schema-tools/meta-schema";
+
+export const jsonPathStringify = (s: string[]): string => {
+  return s
+    .map((i) => {
+      if (i === "") {
+        return "$";
+      } else {
+        return `.${i}`;
+      }
+    })
+    .join("");
+};
+
+export const isCycle = (
+  s: JSONSchema,
+  recursiveStack: JSONSchema[],
+): JSONSchema | false => {
+  const foundInRecursiveStack = recursiveStack.find((recSchema) => recSchema === s);
+  if (foundInRecursiveStack) {
+    return foundInRecursiveStack;
+  }
+  return false;
+};
+
+export const last = (i: JSONSchema[], skip = 1): JSONSchema => {
+  return i[i.length - skip];
+};