@takeshape/json-schema 11.52.0 → 11.55.0

package/dist/__tests__/schema-validator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/schema-validator.test.js

@@ -0,0 +1,295 @@
+import { expect, test } from 'vitest';
+import { createAjv, createSchemaValidator, fixSchema, isInvalidPropertyRequired, validate } from "../schema-validator.js";
+test('createSchemaValidator - missing $id', () => {
+    const testSchema = {
+        type: 'object',
+        properties: {
+            title: { type: 'string' }
+        },
+        required: ['title']
+    };
+    expect(() => createSchemaValidator(testSchema)).toThrowErrorMatchingInlineSnapshot(`[Error: Failed to create schema validator: schema is missing $id]`);
+});
+test('createSchemaValidator - valid', () => {
+    const testSchema = {
+        $id: 'test-schema',
+        type: 'object',
+        properties: {
+            title: { type: 'string' }
+        },
+        required: ['title']
+    };
+    const validate = createSchemaValidator(testSchema);
+    const data = { title: 'this is a title!' };
+    const { valid, errors } = validate(data);
+    expect(valid).toBe(true);
+    expect(errors.length).toBe(0);
+});
+test('createSchemaValidator - ignoreMissing', () => {
+    const testSchema = {
+        $id: 'test-schema',
+        type: 'object',
+        properties: {
+            obj: { type: 'object' }
+        },
+        required: ['obj']
+    };
+    const validate = createSchemaValidator(testSchema);
+    const data = {};
+    const { valid, errors } = validate(data, { ignoreMissing: true });
+    expect(valid).toBe(true);
+    expect(errors.length).toBe(0);
+});
+test('createSchemaValidator - ignoreNulls', () => {
+    const testSchema = {
+        $id: 'test-schema',
+        type: 'object',
+        properties: {
+            title: { type: 'string' },
+            obj: { type: 'object' }
+        },
+        required: ['title']
+    };
+    const validate = createSchemaValidator(testSchema);
+    const data = { obj: null, title: 'title', desc: null };
+    const { valid, errors } = validate(data, { ignoreNulls: true });
+    expect(valid).toBe(true);
+    expect(errors.length).toBe(0);
+});
+test('createSchemaValidator - nulls in unions', () => {
+    const testSchema = {
+        $id: 'test-schema',
+        type: 'object',
+        properties: {
+            title: { type: 'string' },
+            shapeArr: {
+                type: 'array',
+                items: {
+                    discriminator: {
+                        propertyName: '_shapeId'
+                    },
+                    required: ['_shapeId'],
+                    oneOf: [
+                        {
+                            type: 'object',
+                            properties: {
+                                _shapeId: {
+                                    type: 'string',
+                                    enum: ['foo']
+                                },
+                                a: {
+                                    type: 'string'
+                                }
+                            }
+                        },
+                        {
+                            type: 'object',
+                            properties: {
+                                _shapeId: {
+                                    type: 'string',
+                                    enum: ['bar']
+                                },
+                                a: {
+                                    type: 'string'
+                                }
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        required: ['title']
+    };
+    const validate = createSchemaValidator(testSchema);
+    const data = { title: 'title', shapeArr: [{ _shapeId: 'foo', a: null }] };
+    const { valid, errors } = validate(data, { ignoreNulls: true });
+    expect(valid).toBe(true);
+    expect(errors.length).toBe(0);
+});
+const postSchema = {
+    $id: 'post-schema-id',
+    type: 'object',
+    properties: {
+        body: {
+            type: 'string',
+            minLength: 0,
+            description: '',
+            title: 'Body'
+        },
+        title: {
+            type: 'string',
+            minLength: 1,
+            description: '',
+            title: 'Title'
+        },
+        hero: {
+            title: 'Hero',
+            allOf: [
+                {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' }
+                    }
+                },
+                { $ref: '#/definitions/PostHero' }
+            ]
+        }
+    },
+    required: ['title', 'hero'],
+    definitions: {
+        TSRelationship: {
+            type: 'object',
+            properties: {
+                shapeId: {
+                    type: 'string'
+                },
+                contentTypeId: {
+                    type: 'string'
+                },
+                id: {
+                    type: 'string'
+                }
+            },
+            required: ['id']
+        },
+        PostHero: {
+            type: 'object',
+            properties: {
+                gallery: {
+                    type: 'array',
+                    items: {
+                        properties: {
+                            image: {
+                                description: '',
+                                $ref: '#/definitions/TSRelationship',
+                                title: 'Image'
+                            },
+                            caption: {
+                                type: 'string',
+                                minLength: 0,
+                                description: '',
+                                title: 'Caption'
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+test('createSchemaValidator - ignoreNulls nested', () => {
+    const validate = createSchemaValidator(postSchema);
+    const data = {
+        title: 'title',
+        hero: {
+            gallery: [
+                {
+                    caption: 'foo',
+                    image: {
+                        shapeId: 'ASSET',
+                        id: 'asset-id'
+                    }
+                },
+                {
+                    caption: 'bar',
+                    image: null
+                }
+            ]
+        }
+    };
+    const invalidResult = validate(data, { ignoreNulls: false });
+    expect(invalidResult.valid).toBe(false);
+    const validResult = validate(data, { ignoreNulls: true });
+    expect(validResult.valid).toBe(true);
+});
+test('isInvalidPropertyRequired - cannot find parent', () => {
+    const schema = {
+        type: 'string'
+    };
+    const error = {
+        keyword: 'type',
+        instancePath: '/hero/gallery/1/image',
+        schemaPath: '#/definitions/TSRelationship/type',
+        params: {
+            type: 'object'
+        },
+        message: 'should be object'
+    };
+    expect(() => isInvalidPropertyRequired(schema, error)).toThrowErrorMatchingInlineSnapshot(`[Error: Unexpected error cannot find parent schema]`);
+});
+test('fixSchema - remove invalid regex', () => {
+    const schema = {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string' },
+            title: { type: 'string', pattern: '[A-Z].+' }, // Valid
+            gallery: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        slug: { type: 'string', pattern: '[\\w-_]+' } // Invalid
+                    }
+                }
+            }
+        }
+    };
+    expect(fixSchema(schema)).toEqual({
+        type: 'object',
+        properties: {
+            pattern: { type: 'string' },
+            title: { type: 'string', pattern: '[A-Z].+' }, // Valid pattern kept
+            gallery: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        slug: { type: 'string' } // Invalid pattern removed
+                    }
+                }
+            }
+        }
+    });
+});
+test('validate - ignoreNulls', () => {
+    const ajv = createAjv();
+    const testSchema = {
+        definitions: {
+            foo: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string' },
+                    obj: {
+                        $ref: '#/definitions/bar'
+                    }
+                },
+                required: ['title']
+            },
+            bar: {
+                type: 'object',
+                properties: {
+                    a: { type: 'string' },
+                    b: { type: 'string' },
+                    c: { type: 'string' }
+                },
+                required: ['a', 'b']
+            }
+        }
+    };
+    ajv.addSchema(testSchema);
+    const data = {
+        obj: {
+            a: 'A',
+            b: 'B',
+            c: null
+        },
+        title: 'title'
+    };
+    const { valid, errors } = validate(ajv, '#/definitions/foo', data, {
+        ignoreNulls: true
+    });
+    expect(valid).toBe(true);
+    expect(errors.length).toBe(0);
+});

package/dist/converters/__tests__/schema-converter.test.d.ts

@@ -0,0 +1 @@
+export {};