@squiz/dx-json-schema-lib 1.82.2 → 1.82.4

package/src/JsonSchemaService.ts

@@ -1,4 +1,5 @@
 import JSONQuery, { Input } from '@sagold/json-query';
+import cloneDeep from 'lodash.clonedeep';
 
 import DxComponentInputSchema from './manifest/v1/DxComponentInputSchema.json';
 import DxComponentIcons from './manifest/v1/DxComponentIcons.json';
@@ -72,7 +73,37 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
             schema = core.resolveRef(schema);
             callback(schema, data, pointer);
           } else {
-            defaultConfig.each(core, data, callback, schema, pointer);
+            // CRITICAL FIX: Preserve data integrity during allOf schema traversal
+            // Only apply protection for allOf schemas that contain arrays with primitive types
+            if (schema?.allOf && Array.isArray(schema.allOf) && this.hasArraysWithPrimitiveTypes(schema)) {
+              // Get the original input data stored at the beginning of resolveInput
+              const originalInputData = (this as any).__originalInputData;
+
+              // Create a deep clone to prevent Draft library from corrupting original data
+              const safeDataForTraversal = JSON.parse(JSON.stringify(data));
+
+              // Use the safe clone for traversal, but preserve callbacks with original data
+              defaultConfig.each(
+                core,
+                safeDataForTraversal,
+                (resolvedSchema, corruptedValue, resolvedPointer) => {
+                  // Only preserve data for paths that contain arrays of SquizLink/SquizImage
+                  if (this.isProtectedPrimitivePath(resolvedSchema, resolvedPointer)) {
+                    const originalValueAtPointer = originalInputData
+                      ? this.getValueAtPointer(originalInputData, resolvedPointer)
+                      : corruptedValue;
+                    callback(resolvedSchema, originalValueAtPointer, resolvedPointer);
+                  } else {
+                    // Use normal resolution for non-primitive arrays
+                    callback(resolvedSchema, corruptedValue, resolvedPointer);
+                  }
+                },
+                schema,
+                pointer,
+              );
+            } else {
+              defaultConfig.each(core, data, callback, schema, pointer);
+            }
           }
         },
       },
@@ -103,6 +134,42 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
     return this.schema.compileSchema(fullValidationSchema);
   }
 
+  /**
+   * Recursively check if a schema contains allOf combinators that could cause mutation
+   */
+  private hasAllOfCombinator(schema: any, visited: WeakSet<object> = new WeakSet()): boolean {
+    if (!schema || typeof schema !== 'object') return false;
+
+    // Prevent infinite recursion from circular references
+    if (visited.has(schema)) return false;
+    visited.add(schema);
+
+    // Direct allOf check
+    if (schema.allOf) return true;
+
+    // Check in properties
+    if (schema.properties) {
+      for (const prop of Object.values(schema.properties)) {
+        if (this.hasAllOfCombinator(prop, visited)) return true;
+      }
+    }
+
+    // Check in items (arrays)
+    if (schema.items && this.hasAllOfCombinator(schema.items, visited)) return true;
+
+    // Check in nested combinators
+    if (schema.oneOf?.some((subSchema: any) => this.hasAllOfCombinator(subSchema, visited))) return true;
+    if (schema.anyOf?.some((subSchema: any) => this.hasAllOfCombinator(subSchema, visited))) return true;
+    if (schema.not && this.hasAllOfCombinator(schema.not, visited)) return true;
+
+    // Check in conditional schemas (if/then/else)
+    if (schema.if && this.hasAllOfCombinator(schema.if, visited)) return true;
+    if (schema.then && this.hasAllOfCombinator(schema.then, visited)) return true;
+    if (schema.else && this.hasAllOfCombinator(schema.else, visited)) return true;
+
+    return false;
+  }
+
   /**
    * Validate an input value against a specified schema
    * @throws {SchemaValidationError} if the input is invalid
@@ -110,7 +177,13 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
    */
   public validateInput(input: unknown, inputSchema: JSONSchema = this.schema.rootSchema): true | never {
     inputSchema = this.schema.compileSchema(inputSchema);
-    const errors = this.schema.validate(input, inputSchema);
+
+    // Only clone if schema contains allOf combinators that could cause mutation
+    // This optimizes performance by avoiding unnecessary cloning for simple schemas
+    const needsCloning = this.hasAllOfCombinator(inputSchema);
+    const inputToValidate = needsCloning ? cloneDeep(input) : input;
+
+    const errors = this.schema.validate(inputToValidate, inputSchema);
     return processValidationResult(errors);
   }
 
@@ -121,17 +194,50 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
    * @returns the input object with all resolvable shapes resolved
    */
   public async resolveInput(input: Input, inputSchema: JSONSchema, ctx: ResolverContext = {}) {
+    // Store the original input data to prevent corruption during nested allOf processing
+    (this as any).__originalInputData = JSON.parse(JSON.stringify(input));
+
     const setters: Array<Promise<(input: Input) => Input>> = [];
     this.schema.each(
       input,
       async (schema, value, pointer) => {
+        // Debug logging for investigation of resolution path
+        // console.debug('JSONSchemaService.each', {
+        //   pointer,
+        //   title: (schema as any)?.title,
+        //   type: (schema as any)?.type,
+        //   value,
+        // });
+        // Guard: if value is an array of already-resolved primitives (e.g., SquizLink/SquizImage), skip
+        if (Array.isArray(value)) {
+          const isLinkLike = (v: any) =>
+            v && typeof v === 'object' && typeof v.text === 'string' && typeof v.url === 'string';
+          const isImageLike = (v: any) =>
+            v &&
+            typeof v === 'object' &&
+            typeof v.name === 'string' &&
+            v.imageVariations &&
+            typeof v.imageVariations === 'object';
+          const allResolvedPrimitives = value.every((v) => isLinkLike(v) || isImageLike(v));
+          if (allResolvedPrimitives) {
+            return;
+          }
+        }
         // Bug in library for Array item schemas which won't resolve the oneOf schema
         if (Array.isArray(schema?.oneOf)) {
           const oldSchema = schema;
           schema = this.schema.resolveOneOf(value, schema);
           schema.oneOfSchema = oldSchema;
         }
+
+        // Skip resolution if this is already a complete SquizLink or SquizImage
+        // This prevents primitive types from being incorrectly processed when they're already in final form
+        if (this.isAlreadyResolvedPrimitive(schema, value)) {
+          return;
+        }
+
         if (!this.typeResolver.isResolvableSchema(schema)) return;
+
         // If its a resolvable schema, it should exist in a oneOf array with other schemas
         // Including a primitive schema
         const allPossibleSchemaTitles: Array<string> = schema.oneOfSchema.oneOf.map((o: JSONSchema) =>
@@ -140,6 +246,7 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
 
         const primitiveSchema = allPossibleSchemaTitles.find((title) => this.typeResolver.isPrimitiveType(title));
         if (!primitiveSchema) return;
+
         const resolver = this.typeResolver.tryGetResolver(primitiveSchema, schema as any);
         if (!resolver) return;
         const setResolvedData = Promise.resolve()
@@ -163,6 +270,128 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
     if (potentialResolutionErrors.length) {
       throw new Error(`Error(s) occurred when resolving JSON:\n${potentialResolutionErrors.join('\n')}`);
     }
+
+    // Clean up stored original data to prevent memory leaks
+    delete (this as any).__originalInputData;
+
     return input;
   }
+
+  /**
+   * Check if the allOf schema contains arrays with primitive types (SquizLink/SquizImage)
+   * Used to determine if we need to apply data preservation
+   */
+  private hasArraysWithPrimitiveTypes(schema: any): boolean {
+    if (!schema?.allOf || !Array.isArray(schema.allOf)) return false;
+
+    const checkForPrimitiveArrays = (obj: any): boolean => {
+      if (!obj || typeof obj !== 'object') return false;
+
+      // Check if this is an array with SquizLink/SquizImage items
+      if (obj.type === 'array' && obj.items?.type) {
+        return obj.items.type === 'SquizLink' || obj.items.type === 'SquizImage';
+      }
+
+      // Recursively check properties
+      if (obj.properties) {
+        return Object.values(obj.properties).some((prop: any) => checkForPrimitiveArrays(prop));
+      }
+
+      // Check in then/else branches and nested allOf
+      if (obj.then && checkForPrimitiveArrays(obj.then)) return true;
+      if (obj.else && checkForPrimitiveArrays(obj.else)) return true;
+      if (obj.allOf && Array.isArray(obj.allOf)) {
+        return obj.allOf.some((item: any) => checkForPrimitiveArrays(item));
+      }
+
+      return false;
+    };
+
+    // Check both inside allOf conditions AND in the main schema properties
+    // because primitive arrays in main properties can be affected by allOf processing
+    const hasInAllOf = schema.allOf.some((condition: any) => checkForPrimitiveArrays(condition));
+    const hasInMainSchema = checkForPrimitiveArrays(schema);
+
+    return hasInAllOf || hasInMainSchema;
+  }
+
+  /**
+   * Check if a specific schema path should be protected from data corruption
+   * Only protects arrays of SquizLink/SquizImage types
+   */
+  private isProtectedPrimitivePath(resolvedSchema: any, _resolvedPointer: string): boolean {
+    if (!resolvedSchema) return false;
+
+    // Check if this is an array of SquizLink/SquizImage
+    if (resolvedSchema.type === 'array' && resolvedSchema.items?.type) {
+      return resolvedSchema.items.type === 'SquizLink' || resolvedSchema.items.type === 'SquizImage';
+    }
+
+    // Check if this is a direct SquizLink/SquizImage type
+    if (resolvedSchema.type === 'SquizLink' || resolvedSchema.type === 'SquizImage') {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get value at a specific JSON pointer path from the data structure
+   * Used to preserve original data during schema traversal
+   */
+  private getValueAtPointer(data: any, pointer: string): any {
+    if (pointer === '#') return data;
+
+    // Remove the '#/' prefix and split by '/'
+    const path = pointer.replace(/^#\//, '').split('/');
+    let current = data;
+
+    for (const segment of path) {
+      if (current === null || current === undefined) return undefined;
+
+      // Handle array indices
+      if (Array.isArray(current)) {
+        const index = parseInt(segment, 10);
+        if (isNaN(index) || index < 0 || index >= current.length) return undefined;
+        current = current[index];
+      } else if (typeof current === 'object') {
+        // Handle object properties
+        current = current[segment];
+      } else {
+        return undefined;
+      }
+    }
+
+    return current;
+  }
+
+  /**
+   * Check if the value is already a resolved primitive type (SquizLink, SquizImage)
+   * and doesn't need further resolution
+   */
+  private isAlreadyResolvedPrimitive(schema: JSONSchema, value: unknown): boolean {
+    if (!value || typeof value !== 'object') return false;
+
+    // Schema hints: check either title or type when present
+    const schemaType = (schema as any)?.type ?? (schema as any)?.title;
+
+    // Shape-based detection for SquizLink
+    const v: any = value;
+    const looksLikeSquizLink = typeof v.text === 'string' && typeof v.url === 'string';
+    if (looksLikeSquizLink) {
+      if (schemaType === 'SquizLink' || schemaType === undefined) return true;
+      // Even if schema hint differs (e.g., through allOf), preserve already-formed link objects
+      return true;
+    }
+
+    // Shape-based detection for SquizImage
+    const looksLikeSquizImage =
+      typeof v.name === 'string' && v.imageVariations && typeof v.imageVariations === 'object';
+    if (looksLikeSquizImage) {
+      if (schemaType === 'SquizImage' || schemaType === undefined) return true;
+      return true;
+    }
+
+    return false;
+  }
 }