@kravc/schema 2.7.6 → 2.8.0-alpha.0

package/src/helpers/__tests__/cleanupAttributes.test.ts

@@ -0,0 +1,943 @@
+import cleanupAttributes from '../cleanupAttributes';
+import type { ObjectSchema } from '../JsonSchema';
+
+describe('cleanupAttributes(object, jsonSchema, schemasMap)', () => {
+  describe('enum schema', () => {
+    it('should return early and not modify object when schema is an enum', () => {
+      const object = { field1: 'value1', field2: 'value2' };
+      const enumSchema = { enum: ['value1', 'value2', 'value3'] };
+      const schemasMap = {};
+
+      cleanupAttributes(object, enumSchema, schemasMap);
+
+      expect(object).toEqual({ field1: 'value1', field2: 'value2' });
+    });
+  });
+
+  describe('object schema', () => {
+    it('should delete properties not defined in schema', () => {
+      const object = {
+        validField: 'value1',
+        invalidField: 'value2',
+        anotherInvalid: 'value3'
+      };
+      const schema: ObjectSchema = {
+        id: 'test-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+
+      cleanupAttributes(object, schema);
+
+      expect(object).toEqual({ validField: 'value1' });
+      expect(object).not.toHaveProperty('invalidField');
+      expect(object).not.toHaveProperty('anotherInvalid');
+    });
+
+    it('should keep all properties that are defined in schema', () => {
+      const object = {
+        field1: 'value1',
+        field2: 'value2',
+        field3: 'value3'
+      };
+      const schema: ObjectSchema = {
+        id: 'test-schema',
+        properties: {
+          field1: { type: 'string' },
+          field2: { type: 'string' },
+          field3: { type: 'string' }
+        }
+      };
+
+      cleanupAttributes(object, schema);
+
+      expect(object).toEqual({
+        field1: 'value1',
+        field2: 'value2',
+        field3: 'value3'
+      });
+    });
+
+    it('should handle empty object', () => {
+      const object = {};
+      const schema: ObjectSchema = {
+        id: 'test-schema',
+        properties: {
+          field1: { type: 'string' }
+        }
+      };
+
+      cleanupAttributes(object, schema);
+
+      expect(object).toEqual({});
+    });
+
+    it('should handle object with no properties in schema', () => {
+      const object = {
+        field1: 'value1',
+        field2: 'value2'
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {}
+      };
+
+      cleanupAttributes(object, schema);
+
+      expect(object).toEqual({});
+    });
+  });
+
+  describe('reference properties ($ref)', () => {
+    it('should recursively cleanup referenced schema properties', () => {
+      const object = {
+        refField: {
+          validField: 'value1',
+          invalidField: 'value2'
+        }
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'referenced-schema' }
+        }
+      };
+      const referencedSchema: ObjectSchema = {
+        id: 'referenced-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'referenced-schema': referencedSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.refField).toEqual({ validField: 'value1' });
+      expect(object.refField).not.toHaveProperty('invalidField');
+    });
+
+    it('should handle nested references', () => {
+      const object = {
+        refField: {
+          nestedRef: {
+            validField: 'value1',
+            invalidField: 'value2'
+          }
+        }
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'level1-schema' }
+        }
+      };
+      const level1Schema = {
+        id: 'level1-schema',
+        properties: {
+          nestedRef: { $ref: 'level2-schema' }
+        }
+      };
+      const level2Schema: ObjectSchema = {
+        id: 'level2-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'level1-schema': level1Schema,
+        'level2-schema': level2Schema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.refField.nestedRef).toEqual({ validField: 'value1' });
+      expect(object.refField.nestedRef).not.toHaveProperty('invalidField');
+    });
+
+    it('should throw error when referenced schema is not found', () => {
+      const object = {
+        refField: {
+          field: 'value'
+        }
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'non-existent-schema' }
+        }
+      };
+      const schemasMap = {};
+
+      expect(() => {
+        cleanupAttributes(object, schema, schemasMap);
+      }).toThrow('Schema "non-existent-schema" not found');
+    });
+
+    it('should skip cleanup when reference property value is null', () => {
+      const object = {
+        refField: null
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'referenced-schema' }
+        }
+      };
+      const referencedSchema: ObjectSchema = {
+        id: 'referenced-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'referenced-schema': referencedSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.refField).toBeNull();
+    });
+
+    it('should skip cleanup when reference property value is undefined', () => {
+      const object = {
+        refField: undefined
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'referenced-schema' }
+        }
+      };
+      const referencedSchema: ObjectSchema = {
+        id: 'referenced-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'referenced-schema': referencedSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.refField).toBeUndefined();
+    });
+
+    it('should skip cleanup when reference property value is a primitive', () => {
+      const object = {
+        refField: 'string-value'
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'referenced-schema' }
+        }
+      };
+      const referencedSchema: ObjectSchema = {
+        id: 'referenced-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'referenced-schema': referencedSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.refField).toBe('string-value');
+    });
+
+    it('should skip cleanup when reference property value is an array', () => {
+      const object = {
+        refField: ['item1', 'item2']
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'referenced-schema' }
+        }
+      };
+      const referencedSchema: ObjectSchema = {
+        id: 'referenced-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'referenced-schema': referencedSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.refField).toEqual(['item1', 'item2']);
+    });
+  });
+
+  describe('object properties', () => {
+    it('should recursively cleanup nested object properties', () => {
+      const object = {
+        nestedObject: {
+          validField: 'value1',
+          invalidField: 'value2'
+        }
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          nestedObject: {
+            type: 'object' as const,
+            properties: {
+              validField: { type: 'string' }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.nestedObject).toEqual({ validField: 'value1' });
+      expect(object.nestedObject).not.toHaveProperty('invalidField');
+    });
+
+    it('should handle deeply nested objects', () => {
+      const object = {
+        level1: {
+          level2: {
+            level3: {
+              validField: 'value1',
+              invalidField: 'value2'
+            }
+          }
+        }
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          level1: {
+            type: 'object' as const,
+            properties: {
+              level2: {
+                type: 'object' as const,
+                properties: {
+                  level3: {
+                    type: 'object' as const,
+                    properties: {
+                      validField: { type: 'string' }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.level1.level2.level3).toEqual({ validField: 'value1' });
+      expect(object.level1.level2.level3).not.toHaveProperty('invalidField');
+    });
+
+    it('should handle object type with undefined properties (tests destructuring default)', () => {
+      // Create a manually constructed schema with undefined properties to test the default destructuring
+      const object = {
+        nestedObject: {
+          someField: 'value'
+        }
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          nestedObject: {
+            type: 'object' as const,
+            // properties is intentionally undefined to test the default = {} on line 58
+            properties: undefined
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      // Should handle undefined properties by using default {}
+      expect(object.nestedObject).toEqual({});
+    });
+
+    it('should skip cleanup when object property value is null', () => {
+      const object = {
+        nestedObject: null
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          nestedObject: {
+            type: 'object' as const,
+            properties: {
+              validField: { type: 'string' }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.nestedObject).toBeNull();
+    });
+
+    it('should skip cleanup when object property value is undefined', () => {
+      const object = {
+        nestedObject: undefined
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          nestedObject: {
+            type: 'object' as const,
+            properties: {
+              validField: { type: 'string' }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.nestedObject).toBeUndefined();
+    });
+
+    it('should skip cleanup when object property value is a primitive', () => {
+      const object = {
+        nestedObject: 'string-value'
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          nestedObject: {
+            type: 'object' as const,
+            properties: {
+              validField: { type: 'string' }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.nestedObject).toBe('string-value');
+    });
+
+    it('should skip cleanup when object property value is an array', () => {
+      const object = {
+        nestedObject: ['item1', 'item2']
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          nestedObject: {
+            type: 'object' as const,
+            properties: {
+              validField: { type: 'string' }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.nestedObject).toEqual(['item1', 'item2']);
+    });
+  });
+
+  describe('array properties', () => {
+    it('should cleanup array items with reference schema', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1', invalidField: 'value2' },
+          { validField: 'value3', invalidField: 'value4' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: { $ref: 'item-schema' }
+          }
+        }
+      } as ObjectSchema;
+      const itemSchema: ObjectSchema = {
+        id: 'item-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'item-schema': itemSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(2);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[0]).not.toHaveProperty('invalidField');
+      expect(object.arrayField[1]).toEqual({ validField: 'value3' });
+      expect(object.arrayField[1]).not.toHaveProperty('invalidField');
+    });
+
+    it('should cleanup array items with object schema', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1', invalidField: 'value2' },
+          { validField: 'value3', invalidField: 'value4' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(2);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[0]).not.toHaveProperty('invalidField');
+      expect(object.arrayField[1]).toEqual({ validField: 'value3' });
+      expect(object.arrayField[1]).not.toHaveProperty('invalidField');
+    });
+
+    it('should handle empty arrays', () => {
+      const object = {
+        arrayField: []
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: { $ref: 'item-schema' }
+          }
+        }
+      } as ObjectSchema;
+      const itemSchema: ObjectSchema = {
+        id: 'item-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'item-schema': itemSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toEqual([]);
+    });
+
+    it('should handle arrays with mixed valid and invalid properties', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1' },
+          { validField: 'value2', invalidField: 'value3' },
+          { invalidField: 'value4' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(3);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[1]).toEqual({ validField: 'value2' });
+      expect(object.arrayField[1]).not.toHaveProperty('invalidField');
+      expect(object.arrayField[2]).toEqual({});
+      expect(object.arrayField[2]).not.toHaveProperty('invalidField');
+    });
+
+    it('should skip cleanup when array property value is not an array', () => {
+      const object = {
+        arrayField: 'not-an-array'
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toBe('not-an-array');
+    });
+
+    it('should skip cleanup when array property value is null', () => {
+      const object = {
+        arrayField: null
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toBeNull();
+    });
+
+    it('should skip cleanup when array property value is undefined', () => {
+      const object = {
+        arrayField: undefined
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toBeUndefined();
+    });
+
+    it('should skip cleanup for array items that are null', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1' },
+          null,
+          { validField: 'value2' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(3);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[1]).toBeNull();
+      expect(object.arrayField[2]).toEqual({ validField: 'value2' });
+    });
+
+    it('should skip cleanup for array items that are undefined', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1' },
+          undefined,
+          { validField: 'value2' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(3);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[1]).toBeUndefined();
+      expect(object.arrayField[2]).toEqual({ validField: 'value2' });
+    });
+
+    it('should skip cleanup for array items that are primitives', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1' },
+          'string-item',
+          123,
+          true,
+          { validField: 'value2' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(5);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[1]).toBe('string-item');
+      expect(object.arrayField[2]).toBe(123);
+      expect(object.arrayField[3]).toBe(true);
+      expect(object.arrayField[4]).toEqual({ validField: 'value2' });
+    });
+
+    it('should skip cleanup for array items that are arrays', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1' },
+          ['nested', 'array'],
+          { validField: 'value2' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField).toHaveLength(3);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1' });
+      expect(object.arrayField[1]).toEqual(['nested', 'array']);
+      expect(object.arrayField[2]).toEqual({ validField: 'value2' });
+    });
+  });
+
+  describe('complex nested scenarios', () => {
+    it('should handle object with mix of reference, object, and array properties', () => {
+      const object = {
+        refField: {
+          validField: 'value1',
+          invalidField: 'value2'
+        },
+        nestedObject: {
+          validField: 'value3',
+          invalidField: 'value4'
+        },
+        arrayField: [
+          { validField: 'value5', invalidField: 'value6' }
+        ],
+        invalidTopLevel: 'should be deleted'
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          refField: { $ref: 'ref-schema' },
+          nestedObject: {
+            type: 'object' as const,
+            properties: {
+              validField: { type: 'string' }
+            }
+          },
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                validField: { type: 'string' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const refSchema: ObjectSchema = {
+        id: 'ref-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'ref-schema': refSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object).not.toHaveProperty('invalidTopLevel');
+      expect(object.refField).toEqual({ validField: 'value1' });
+      expect(object.refField).not.toHaveProperty('invalidField');
+      expect(object.nestedObject).toEqual({ validField: 'value3' });
+      expect(object.nestedObject).not.toHaveProperty('invalidField');
+      expect(object.arrayField[0]).toEqual({ validField: 'value5' });
+      expect(object.arrayField[0]).not.toHaveProperty('invalidField');
+    });
+
+    it('should handle array of objects with nested references', () => {
+      const object = {
+        arrayField: [
+          {
+            refField: {
+              validField: 'value1',
+              invalidField: 'value2'
+            }
+          }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const,
+            items: {
+              type: 'object' as const,
+              properties: {
+                refField: { $ref: 'nested-ref-schema' }
+              }
+            }
+          }
+        }
+      } as ObjectSchema;
+      const nestedRefSchema: ObjectSchema = {
+        id: 'nested-ref-schema',
+        properties: {
+          validField: { type: 'string' }
+        }
+      };
+      const schemasMap = {
+        'nested-ref-schema': nestedRefSchema
+      };
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      expect(object.arrayField[0].refField).toEqual({ validField: 'value1' });
+      expect(object.arrayField[0].refField).not.toHaveProperty('invalidField');
+    });
+  });
+
+  describe('edge cases and error handling', () => {
+    it('should skip cleanup when array property has undefined items', () => {
+      const object = {
+        arrayField: [
+          { validField: 'value1', invalidField: 'value2' },
+          { validField: 'value3', invalidField: 'value4' }
+        ]
+      };
+      const schema = {
+        id: 'test-schema',
+        properties: {
+          arrayField: {
+            type: 'array' as const
+            // items is intentionally undefined
+          }
+        }
+      } as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      // Should not modify array items when items schema is undefined
+      expect(object.arrayField).toHaveLength(2);
+      expect(object.arrayField[0]).toEqual({ validField: 'value1', invalidField: 'value2' });
+      expect(object.arrayField[1]).toEqual({ validField: 'value3', invalidField: 'value4' });
+    });
+
+    it('should return early when objectSchema has undefined properties', () => {
+      const object = {
+        field1: 'value1',
+        field2: 'value2'
+      };
+      const schema = {
+        id: 'test-schema'
+        // properties is intentionally undefined (malformed schema)
+      } as unknown as ObjectSchema;
+      const schemasMap = {};
+
+      cleanupAttributes(object, schema, schemasMap);
+
+      // Should not modify object when properties is undefined
+      expect(object).toEqual({ field1: 'value1', field2: 'value2' });
+    });
+  });
+});