@takeshape/json-schema 11.72.0 → 11.74.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/json-schema",
-  "version": "11.72.0",
+  "version": "11.74.1",
   "description": "JSON Schema validator",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -38,7 +38,7 @@
     "ajv-formats": "3.0.1",
     "lodash": "^4.17.21",
     "minimatch": "^3.0.4",
-    "@takeshape/util": "11.72.0"
+    "@takeshape/util": "11.74.1"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.7",
@@ -49,7 +49,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsc --build tsconfig.build.json",
+    "build": "tsc --project tsconfig.build.json",
     "prebuild:ci": "pnpm clean",
     "build:ci": "pnpm build --noCheck",
     "clean": "del-cli dist coverage *.tsbuildinfo",

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

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

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

@@ -1,323 +0,0 @@
-import { expect, test } from 'vitest';
-import { createAjv, createSchemaValidator, createTypedValidator, 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);
-});
-test('createTypedValidator - valid data', () => {
-    const schema = {
-        type: 'object',
-        properties: {
-            id: { type: 'string' },
-            name: { type: 'string' }
-        },
-        required: ['id', 'name']
-    };
-    const validate = createTypedValidator(schema);
-    const data = { id: '123', name: 'Test' };
-    expect(validate(data)).toBe(true);
-});
-test('createTypedValidator - invalid data', () => {
-    const schema = {
-        type: 'object',
-        properties: {
-            id: { type: 'string' },
-            name: { type: 'string' }
-        },
-        required: ['id', 'name']
-    };
-    const validate = createTypedValidator(schema);
-    const data = { id: '123' }; // Missing 'name'
-    expect(validate(data)).toBe(false);
-    expect(validate.errors).toBeDefined();
-    expect(validate.errors?.[0].message).toBe("must have required property 'name'");
-});

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

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