chore: refactor a bit

Author: BelfordZ

src/index.ts

@@ -71,38 +71,18 @@ 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.
- *
- * @param schema the schema to traverse
- * @param mutation the function to pass each node in the subschema tree.
- * @param traverseOptions a set of options for traversal.
- * @param depth For internal use. Tracks the current recursive depth in the tree. This is used to implement
- *              some of the options.
- *
- */
-export default function traverse(
+
+const _traverse = (
   schema: JSONSchema,
   mutation: MutationFunction,
-  traverseOptions = defaultOptions,
+  opts: TraverseOptions,
   depth = 0,
   recursiveStack: JSONSchema[] = [],
   mutableStack: JSONSchema[] = [],
   pathStack: string[] = [],
   prePostMap: Array<[JSONSchema, JSONSchema]> = [],
   cycleSet: JSONSchema[] = [],
-): JSONSchema {
-  const opts = { ...defaultOptions, ...traverseOptions }; // would be nice to make an 'entry' func when we get around to optimizations
-
-  // booleans are a bit messed. Since all other schemas are objects (non-primitive type
-  // which gets a new address in mem) for each new JS refer to one of 2 memory addrs, and
-  // thus adding it to the recursive stack will prevent it from being explored if the
-  // boolean is seen in a further nested schema.
-  if (depth === 0) {
-    pathStack = [""];
-  }
-
+) => {
   if (typeof schema === "boolean" || schema instanceof Boolean) {
     if (opts.skipFirstMutation === true && depth === 0) {
       return schema;
@@ -161,10 +141,10 @@ export default function traverse(
     }
 
     // else
-    return traverse(
+    return _traverse(
       s,
       mutation,
-      traverseOptions,
+      opts,
       depth + 1,
       recursiveStack,
       mutableStack,
@@ -216,10 +196,10 @@ export default function traverse(
             mutableSchema.items = cycledMutableSchema;
           }
         } else {
-          mutableSchema.items = traverse(
+          mutableSchema.items = _traverse(
             schema.items,
             mutation,
-            traverseOptions,
+            opts,
             depth + 1,
             recursiveStack,
             mutableStack,
@@ -282,4 +262,40 @@ export default function traverse(
       last(mutableStack)
     );
   }
+};
+
+
+/**
+ * Traverse all subschema of a schema, calling the mutator function with each.
+ * The mutator is called on leaf nodes first.
+ *
+ * @param schema the schema to traverse
+ * @param mutation the function to pass each node in the subschema tree.
+ * @param traverseOptions a set of options for traversal.
+ * @param depth For internal use. Tracks the current recursive depth in the tree. This is used to implement
+ *              some of the options.
+ *
+ */
+export default function traverse(
+  schema: JSONSchema,
+  mutation: MutationFunction,
+  traverseOptions = defaultOptions,
+): JSONSchema {
+  const opts = { ...defaultOptions, ...traverseOptions }; // would be nice to make an 'entry' func when we get around to optimizations
+
+  return _traverse(
+    schema,
+    mutation,
+    opts,
+    0,
+    [],
+    [],
+    // booleans are a bit messed. Since all other schemas are objects (non-primitive type
+    // which gets a new address in mem) for each new JS refer to one of 2 memory addrs, and
+    // thus adding it to the recursive stack will prevent it from being explored if the
+    // boolean is seen in a further nested schema.
+    [""],
+    [],
+    [],
+  );
 }

src/mutability.test.ts

@@ -0,0 +1,114 @@
+// Required imports
+import traverse, { TraverseOptions } from './';
+import { JSONSchema } from '@json-schema-tools/meta-schema';
+
+// Example schemas for testing
+const exampleSchema: JSONSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    age: { type: 'number' },
+  },
+};
+
+// Test cases for different behaviors
+describe('traverse mutability behavior', () => {
+  it('should modify the original schema when mutable is true and mutation modifies properties directly', () => {
+    const mutableSchema = { ...exampleSchema };
+    const mutationFn = (schema: any) => {
+      if (typeof schema === 'object' && schema.type === 'string') {
+        schema.type = 'number'; // Directly modify the schema
+      }
+      return schema;
+    };
+
+    traverse(mutableSchema, mutationFn, { mutable: true } as TraverseOptions);
+
+    expect(mutableSchema.properties?.name.type).toBe('number'); // Original schema is modified
+  });
+
+  it('should not modify the original schema when mutable is false and mutation modifies properties directly', () => {
+    const mutableSchema = { ...exampleSchema };
+    const mutationFn = (schema: any) => {
+      if (typeof schema === 'object' && schema.type === 'string') {
+        schema.type = 'number'; // Directly modify the schema
+      }
+      return schema;
+    };
+
+    const result: any = traverse(mutableSchema, mutationFn, { mutable: false } as TraverseOptions);
+
+    expect(mutableSchema.properties?.name.type).toBe('string'); // Original schema remains unchanged
+    expect(result.properties.name.type).toBe('number'); // Modified copy
+  });
+
+  it('should replace the schema with a new object when mutation returns a new schema (mutable true)', () => {
+    const mutableSchema = { ...exampleSchema };
+    const mutationFn = (schema: any) => {
+      if (typeof schema === 'object' && schema.type === 'string') {
+        return { ...schema, type: 'boolean' }; // Return a new object
+      }
+      return schema;
+    };
+
+    traverse(mutableSchema, mutationFn, { mutable: true } as TraverseOptions);
+
+    expect(mutableSchema.properties?.name.type).toBe('boolean'); // Original schema is replaced
+  });
+
+  it('should replace the schema with a new object when mutation returns a new schema (mutable false)', () => {
+    const mutableSchema = { ...exampleSchema };
+    const mutationFn = (schema: any) => {
+      if (typeof schema === 'object' && schema.type === 'string') {
+        return { ...schema, type: 'boolean' }; // Return a new object
+      }
+      return schema;
+    };
+
+    const result: any = traverse(mutableSchema, mutationFn, { mutable: false } as TraverseOptions);
+
+    expect(mutableSchema.properties?.name.type).toBe('string'); // Original schema remains unchanged
+    expect(result.properties.name.type).toBe('boolean'); // Modified copy
+  });
+
+  it('should skip the first mutation when skipFirstMutation is true', () => {
+    const mutableSchema = { ...exampleSchema };
+    const mutationFn = (schema: any) => {
+      if (typeof schema === 'object' && schema.type) {
+        schema.type = 'null'; // Directly modify the schema
+      }
+      return schema;
+    };
+
+    const result: any = traverse(mutableSchema, mutationFn, { skipFirstMutation: true } as TraverseOptions);
+
+    expect(result.type).toBeUndefined(); // Root is not mutated
+    expect(result.properties.name.type).toBe('null'); // Subschemas are mutated
+  });
+
+  it('should traverse in breadth-first manner when bfs is true', () => {
+    const bfsSchema: JSONSchema = {
+      type: 'object',
+      properties: {
+        nested: {
+          type: 'object',
+          properties: {
+            deep: { type: 'string' },
+          },
+        },
+      },
+    };
+
+    const order: string[] = [];
+    const mutationFn = (schema: any) => {
+      if (typeof schema === 'object' && schema.type) {
+        order.push(schema.type);
+      }
+      return schema;
+    };
+
+    traverse(bfsSchema, mutationFn, { bfs: true } as TraverseOptions);
+
+    expect(order).toEqual(['object', 'object', 'string']); // Breadth-first order
+  });
+});