@squiz/dx-json-schema-lib 1.82.1 → 1.82.3

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';
@@ -103,6 +104,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 +147,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);
   }
 

package/src/formatted-text/v1/formattedText.json

@@ -243,7 +243,7 @@
         },
         "formattingOptions": { "$ref": "#/definitions/FormattingOptions" },
         "type": { "const": "link-to-dam-asset" },
-        "damSystemType": { "enum": ["bynder"] },
+        "damSystemType": { "type": "string", "minLength": 1 },
         "damSystemIdentifier": { "type": "string", "minLength": 1 },
         "damObjectId": { "type": "string", "minLength": 1 },
         "damAdditional": { "type": "object", "properties": { "variant": { "type": "string", "minLength": 1 } } },
@@ -309,7 +309,7 @@
 
       "properties": {
         "type": { "const": "dam-image" },
-        "damSystemType": { "enum": ["bynder"] },
+        "damSystemType": { "type": "string", "minLength": 1 },
         "damSystemIdentifier": { "type": "string", "minLength": 1 },
         "damObjectId": { "type": "string", "minLength": 1 },
         "damAdditional": { "type": "object", "properties": { "variant": { "type": "string", "minLength": 1 } } },

package/src/formatted-text/v1/formattedText.ts

@@ -40,7 +40,7 @@ export interface FormattedTextLinkToDamAsset {
   children: WithChildrenNode;
   formattingOptions?: FormattingOptions;
   type: 'link-to-dam-asset';
-  damSystemType: 'bynder';
+  damSystemType: string;
   damSystemIdentifier: string;
   damObjectId: string;
   damAdditional?: {
@@ -72,7 +72,7 @@ export interface FormattedTextMatrixImage {
 }
 export interface FormattedTextDamImage {
   type: 'dam-image';
-  damSystemType: 'bynder';
+  damSystemType: string;
   damSystemIdentifier: string;
   damObjectId: string;
   damAdditional?: {

package/src/hasAllOfCombinator.spec.ts

@@ -0,0 +1,456 @@
+import { JSONSchemaService } from './JsonSchemaService';
+import { ComponentInputMetaSchema } from './JsonSchemaService';
+import { TypeResolverBuilder } from './jsonTypeResolution/TypeResolverBuilder';
+
+describe('JSONSchemaService - hasAllOfCombinator', () => {
+  let jsonSchemaService: JSONSchemaService<any, any>;
+
+  beforeAll(() => {
+    const typeResolverBuilder = new TypeResolverBuilder();
+    const typeResolver = typeResolverBuilder.build();
+    jsonSchemaService = new JSONSchemaService(typeResolver, ComponentInputMetaSchema);
+  });
+
+  // Helper to access private method
+  const hasAllOfCombinator = (schema: any) => (jsonSchemaService as any).hasAllOfCombinator(schema);
+
+  describe('Direct allOf detection', () => {
+    it('should detect direct allOf usage', () => {
+      const schema = {
+        type: 'object',
+        allOf: [{ properties: { name: { type: 'string' } } }, { properties: { age: { type: 'number' } } }],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect empty allOf array', () => {
+      const schema = {
+        type: 'object',
+        allOf: [],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+  });
+
+  describe('Nested allOf detection', () => {
+    it('should detect allOf in properties', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          user: {
+            allOf: [{ properties: { name: { type: 'string' } } }, { properties: { email: { type: 'string' } } }],
+          },
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect allOf in deeply nested properties', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          componentContent: {
+            type: 'object',
+            properties: {
+              heroSection: {
+                allOf: [
+                  { properties: { title: { type: 'string' } } },
+                  { properties: { subtitle: { type: 'string' } } },
+                ],
+              },
+            },
+          },
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect allOf in array items', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          items: {
+            type: 'array',
+            items: {
+              allOf: [{ properties: { id: { type: 'number' } } }, { properties: { name: { type: 'string' } } }],
+            },
+          },
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+  });
+
+  describe('Combinator traversal', () => {
+    it('should detect allOf within oneOf', () => {
+      const schema = {
+        type: 'object',
+        oneOf: [
+          {
+            allOf: [{ properties: { type: { const: 'A' } } }, { properties: { valueA: { type: 'string' } } }],
+          },
+          { properties: { type: { const: 'B' } } },
+        ],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect allOf within anyOf', () => {
+      const schema = {
+        type: 'object',
+        anyOf: [
+          { properties: { simple: { type: 'string' } } },
+          {
+            allOf: [{ properties: { complex: { type: 'object' } } }, { properties: { nested: { type: 'array' } } }],
+          },
+        ],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect allOf within not schema', () => {
+      const schema = {
+        type: 'object',
+        not: {
+          allOf: [{ properties: { forbidden: { type: 'string' } } }, { properties: { invalid: { type: 'number' } } }],
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+  });
+
+  describe('Conditional schema detection', () => {
+    it('should detect allOf in if condition', () => {
+      const schema = {
+        type: 'object',
+        if: {
+          allOf: [{ properties: { type: { const: 'special' } } }, { properties: { mode: { const: 'advanced' } } }],
+        },
+        then: { properties: { specialValue: { type: 'string' } } },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect allOf in then branch', () => {
+      const schema = {
+        type: 'object',
+        if: { properties: { type: { const: 'special' } } },
+        then: {
+          allOf: [{ properties: { requiredProp: { type: 'string' } } }, { required: ['requiredProp'] }],
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should detect allOf in else branch', () => {
+      const schema = {
+        type: 'object',
+        if: { properties: { type: { const: 'simple' } } },
+        then: { properties: { simpleValue: { type: 'string' } } },
+        else: {
+          allOf: [
+            { properties: { complexValue: { type: 'object' } } },
+            { properties: { metadata: { type: 'object' } } },
+          ],
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+  });
+
+  describe('Complex nested scenarios', () => {
+    it('should detect allOf in Hero Banner-like schema', () => {
+      const heroBannerSchema = {
+        type: 'object',
+        properties: {
+          componentContent: {
+            allOf: [
+              {
+                if: { properties: { heroType: { const: 'Supporting content' } } },
+                then: {
+                  type: 'object',
+                  properties: {
+                    heroType: { type: 'string' },
+                    heading: { type: 'string' },
+                    content: { type: 'string' },
+                    links: {
+                      type: 'array',
+                      items: {
+                        type: 'object',
+                        properties: {
+                          text: { type: 'string' },
+                          url: { type: 'string' },
+                          target: { type: 'string' },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+              {
+                if: { properties: { heroType: { const: 'Supporting image' } } },
+                then: {
+                  properties: {
+                    image: { type: 'object' },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      expect(hasAllOfCombinator(heroBannerSchema)).toBe(true);
+    });
+
+    it('should detect allOf in very deeply nested structure', () => {
+      const deepSchema = {
+        type: 'object',
+        properties: {
+          level1: {
+            properties: {
+              level2: {
+                oneOf: [
+                  {
+                    properties: {
+                      level3: {
+                        anyOf: [
+                          {
+                            allOf: [{ properties: { deep: { type: 'string' } } }],
+                          },
+                        ],
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      };
+
+      expect(hasAllOfCombinator(deepSchema)).toBe(true);
+    });
+  });
+
+  describe('Negative cases - should return false', () => {
+    it('should return false for simple object schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+        required: ['name'],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+
+    it('should return false for schema with only oneOf', () => {
+      const schema = {
+        type: 'object',
+        oneOf: [{ properties: { typeA: { type: 'string' } } }, { properties: { typeB: { type: 'number' } } }],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+
+    it('should return false for schema with only anyOf', () => {
+      const schema = {
+        type: 'object',
+        anyOf: [{ properties: { option1: { type: 'string' } } }, { properties: { option2: { type: 'boolean' } } }],
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+
+    it('should return false for array schema without allOf', () => {
+      const schema = {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'number' },
+            name: { type: 'string' },
+          },
+        },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+
+    it('should return false for conditional schema without allOf', () => {
+      const schema = {
+        type: 'object',
+        if: { properties: { type: { const: 'special' } } },
+        then: { properties: { specialValue: { type: 'string' } } },
+        else: { properties: { normalValue: { type: 'string' } } },
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should return false for null', () => {
+      expect(hasAllOfCombinator(null)).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(hasAllOfCombinator(undefined)).toBe(false);
+    });
+
+    it('should return false for string', () => {
+      expect(hasAllOfCombinator('not an object')).toBe(false);
+    });
+
+    it('should return false for number', () => {
+      expect(hasAllOfCombinator(42)).toBe(false);
+    });
+
+    it('should return false for boolean', () => {
+      expect(hasAllOfCombinator(true)).toBe(false);
+    });
+
+    it('should return false for array', () => {
+      expect(hasAllOfCombinator(['not', 'a', 'schema'])).toBe(false);
+    });
+
+    it('should return false for empty object', () => {
+      expect(hasAllOfCombinator({})).toBe(false);
+    });
+
+    it('should handle circular references gracefully', () => {
+      const schema: any = {
+        type: 'object',
+        properties: {
+          self: null,
+        },
+      };
+      schema.properties.self = schema; // Create circular reference
+
+      // Should not crash and should return false (no allOf)
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+
+    it('should handle circular references with allOf', () => {
+      const schema: any = {
+        type: 'object',
+        allOf: [{ properties: { name: { type: 'string' } } }],
+        properties: {
+          self: null,
+        },
+      };
+      schema.properties.self = schema; // Create circular reference
+
+      // Should detect allOf despite circular reference
+      expect(hasAllOfCombinator(schema)).toBe(true);
+    });
+
+    it('should handle deeply circular references', () => {
+      const schemaA: any = {
+        type: 'object',
+        properties: {
+          b: null,
+        },
+      };
+
+      const schemaB: any = {
+        type: 'object',
+        properties: {
+          a: schemaA,
+          c: null,
+        },
+      };
+
+      const schemaC: any = {
+        type: 'object',
+        properties: {
+          b: schemaB,
+        },
+      };
+
+      // Create circular chain: A -> B -> C -> B
+      schemaA.properties.b = schemaB;
+      schemaB.properties.c = schemaC;
+
+      // Should not crash and should return false (no allOf in any of them)
+      expect(hasAllOfCombinator(schemaA)).toBe(false);
+      expect(hasAllOfCombinator(schemaB)).toBe(false);
+      expect(hasAllOfCombinator(schemaC)).toBe(false);
+    });
+
+    it('should handle malformed properties object', () => {
+      const schema = {
+        type: 'object',
+        properties: null, // Malformed properties
+      };
+
+      expect(hasAllOfCombinator(schema)).toBe(false);
+    });
+  });
+
+  describe('Performance characteristics', () => {
+    it('should quickly process large schema without allOf', () => {
+      const largeSchema = {
+        type: 'object',
+        properties: {},
+      };
+
+      // Generate 100 properties
+      for (let i = 0; i < 100; i++) {
+        (largeSchema.properties as any)[`prop${i}`] = {
+          type: 'object',
+          properties: {
+            [`nested${i}`]: { type: 'string' },
+            [`array${i}`]: {
+              type: 'array',
+              items: { type: 'number' },
+            },
+          },
+        };
+      }
+
+      const startTime = performance.now();
+      const result = hasAllOfCombinator(largeSchema);
+      const endTime = performance.now();
+
+      expect(result).toBe(false);
+      expect(endTime - startTime).toBeLessThan(10); // Should be very fast (< 10ms)
+    });
+
+    it('should quickly detect allOf in large schema', () => {
+      const largeSchemaWithAllOf = {
+        type: 'object',
+        allOf: [{ properties: { detected: { type: 'string' } } }],
+        properties: {},
+      };
+
+      // Generate 100 properties
+      for (let i = 0; i < 100; i++) {
+        (largeSchemaWithAllOf.properties as any)[`prop${i}`] = {
+          type: 'string',
+        };
+      }
+
+      const startTime = performance.now();
+      const result = hasAllOfCombinator(largeSchemaWithAllOf);
+      const endTime = performance.now();
+
+      expect(result).toBe(true);
+      expect(endTime - startTime).toBeLessThan(5); // Should be very fast due to early detection
+    });
+  });
+});