@squiz/dx-json-schema-lib 1.79.0 → 1.80.0

package/lib/JsonValidationService.spec.js

@@ -8,10 +8,7 @@ const SchemaValidationError_1 = require("./errors/SchemaValidationError");
 const validComponent_json_1 = __importDefault(require("./manifest/v1/__test__/schemas/validComponent.json"));
 const validComponentJson_json_1 = __importDefault(require("./manifest/v1/__test__/schemas/validComponentJson.json"));
 const inputStringWithFormat_json_1 = __importDefault(require("./manifest/v1/__test__/schemas/inputStringWithFormat.json"));
-const TypeResolver_1 = require("./jsonTypeResolution/TypeResolver");
-const primitiveTypes_1 = require("./primitiveTypes");
-const TypeResolverBuilder_1 = require("./jsonTypeResolution/TypeResolverBuilder");
-const resolvableTypes_1 = require("./resolvableTypes");
+const invalidUiMetadata_json_1 = __importDefault(require("./manifest/v1/__test__/schemas/invalidUiMetadata.json"));
 function expectToThrowErrorMatchingTypeAndMessage(
 // eslint-disable-next-line @typescript-eslint/ban-types
 received, 
@@ -91,6 +88,23 @@ describe('JsonValidationService', () => {
                 ],
             });
         });
+        it('should throw error for invalid ui:metadata options', () => {
+            expectToThrowErrorMatchingTypeAndMessage(() => {
+                jsonValidationService.validateManifest(invalidUiMetadata_json_1.default, 'v1');
+            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: ui:metadata property quickOption is only valid for enum based properties.', {
+                '#/functions/0/input/properties/prop': [
+                    {
+                        data: {
+                            expected: 'enum',
+                            pointer: '#/functions/0/input/properties/prop',
+                            received: 'object',
+                            value: { type: 'string', 'ui:metadata': { quickOption: true } },
+                        },
+                        message: 'ui:metadata property quickOption is only valid for enum based properties.',
+                    },
+                ],
+            });
+        });
     });
     describe('validateRenderInput', () => {
         describe('matrix-asset-uri input', () => {
@@ -212,21 +226,7 @@ describe('JsonValidationService', () => {
             const value = {
                 'my-input': [{ type: 'text', value: 'hello' }],
             };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonValidationService.validateRenderInput(schema, value);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected `Array [{"type":"text","value":"hello"}]` (array) in `#/my-input` to be of type `string`', {
-                '#/my-input': [
-                    {
-                        message: 'Expected `Array [{"type":"text","value":"hello"}]` (array) in `#/my-input` to be of type `string`',
-                        data: {
-                            received: 'array',
-                            expected: 'string',
-                            value: [{ type: 'text', value: 'hello' }],
-                            pointer: '#/my-input',
-                        },
-                    },
-                ],
-            });
+            expect(() => jsonValidationService.validateRenderInput(schema, value)).toThrowError(SchemaValidationError_1.SchemaValidationError);
         });
         it('should validate a property with type FormattedText within an if/then/else as string', () => {
             const schema = {
@@ -272,1785 +272,4 @@ describe('JsonValidationService', () => {
         });
     });
 });
-const defaultSchema = {
-    type: 'object',
-    properties: {
-        myProperty: {
-            type: 'string',
-        },
-    },
-    required: ['myProperty'],
-};
-function primitiveTypeFixture(title, schema = defaultSchema) {
-    return (0, TypeResolver_1.PrimitiveType)({
-        ...schema,
-        title,
-    });
-}
-function resolvableTypeFixture(title, schema = defaultSchema) {
-    return (0, TypeResolver_1.ResolvableType)({
-        ...schema,
-        title,
-    });
-}
-describe('JsonSchemaService', () => {
-    let jsonSchemaService;
-    beforeAll(() => {
-        const typeResolver = new TypeResolver_1.TypeResolver([primitiveTypes_1.FormattedTextType]);
-        jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-    });
-    describe('validateContentSchema', () => {
-        it('should return true for a valid content schema', () => {
-            const contentSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'number' },
-                },
-                required: ['my-input'],
-            };
-            const result = jsonSchemaService.validateInput(contentSchema);
-            expect(result).toBe(true);
-        });
-        it('should return false for an invalid content schema, where the required property is missed from a child object', () => {
-            const contentSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': {
-                        type: 'object',
-                        properties: {
-                            'my-deep-input': { type: 'object' },
-                        },
-                    },
-                },
-                required: ['my-input'],
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(contentSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: The required property `required` is missing at `#/properties/my-input`', {
-                '#/properties/my-input': [
-                    {
-                        data: { key: 'required', pointer: '#/properties/my-input' },
-                        message: 'The required property `required` is missing at `#/properties/my-input`',
-                    },
-                ],
-            });
-        });
-        it('should throw a SchemaValidationError for an invalid content schema, top level type must be object', () => {
-            const contentSchema = {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        'my-input': { type: 'number' },
-                    },
-                    required: ['my-input'],
-                },
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(contentSchema);
-            }, SchemaValidationError_1.SchemaValidationError, `failed validation: Expected value at \`#/type\` to be \`object\`, but value given is \`array\``, {
-                '#/type': [
-                    {
-                        data: { expected: 'object', pointer: '#/type', value: 'array' },
-                        message: 'Expected value at `#/type` to be `object`, but value given is `array`',
-                    },
-                ],
-            });
-        });
-        it('should throw a SchemaValidationError for an invalid content schema missing the required property', () => {
-            const contentSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'number' },
-                },
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(contentSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: The required property `required` is missing at `#`', {
-                '#': [
-                    { data: { key: 'required', pointer: '#' }, message: 'The required property `required` is missing at `#`' },
-                ],
-            });
-        });
-    });
-    describe('SquizImage input', () => {
-        it('should validate a squizImage input', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    image: {
-                        type: 'SquizImage',
-                    },
-                },
-            };
-            const value = {
-                name: 'My Image',
-                alt: 'My Image that did not load',
-                caption: 'This above is a loaded image',
-                imageVariations: {
-                    original: {
-                        url: 'https://picsum.photos/200/300',
-                        width: 100,
-                        height: 100,
-                        byteSize: 1000,
-                        mimeType: 'image/jpeg',
-                        aspectRatio: '1:1',
-                        sha1Hash: '1234567890abcdef1234567890abcdef12345678',
-                    },
-                },
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
-        });
-        it('should error if SquizImage type is missing required properties', async () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    myProp: {
-                        type: 'SquizImage',
-                    },
-                },
-            };
-            const value = {
-                // @ts-expect-error - missing required properties
-                myProp: {
-                    alt: 'alt',
-                    caption: 'caption',
-                    name: 'name',
-                },
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(value, schema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected `Object {"alt":"alt","caption":"caption","name":"name"}` (object) in `#/myProp` to be of type `SquizImage`', {
-                '#/myProp': [
-                    {
-                        data: {
-                            expected: 'SquizImage',
-                            pointer: '#/myProp',
-                            received: 'object',
-                            value: { alt: 'alt', caption: 'caption', name: 'name' },
-                        },
-                        message: 'Expected `Object {"alt":"alt","caption":"caption","name":"name"}` (object) in `#/myProp` to be of type `SquizImage`',
-                    },
-                ],
-            });
-        });
-    });
-    describe('FormattedText input', () => {
-        it('should handle type as an array', () => {
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: ['number', 'string'] },
-                },
-                required: ['my-input'],
-            };
-            expect(jsonSchemaService.validateInput({
-                'my-input': 'formattedText',
-            }, functionInputSchema)).toEqual(true);
-            expect(jsonSchemaService.validateInput({
-                'my-input': 123,
-            }, functionInputSchema)).toEqual(true);
-        });
-        it.failing('should handle type is an array of both string and FormattedText', () => {
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [
-                        { type: 'text', value: 'This is some ' },
-                        { type: 'text', value: 'Link to asset 12345' },
-                        { type: 'text', value: ' with an image ' },
-                        { type: 'text', value: '.' },
-                    ],
-                },
-            ];
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: ['FormattedText', 'string'] },
-                },
-                required: ['my-input'],
-            };
-            expect(jsonSchemaService.validateInput({
-                'my-input': formattedText,
-            }, functionInputSchema)).toEqual(true);
-            expect(jsonSchemaService.validateInput({
-                'my-input': 'hello',
-            }, functionInputSchema)).toEqual(true);
-        });
-        it('should return true if input is formatted text', () => {
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [
-                        { type: 'text', value: 'This is some ' },
-                        { type: 'text', value: 'Link to asset 12345' },
-                        { type: 'text', value: ' with an image ' },
-                        { type: 'text', value: '.' },
-                    ],
-                },
-            ];
-            const inputValue = {
-                'my-input': formattedText,
-            };
-            expect(() => jsonSchemaService.validateInput(inputValue, functionInputSchema)).not.toThrow();
-        });
-        it('should throw an error if the FormattedText input is not formatted text', () => {
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const inputValue = {
-                'my-input': 123,
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `123` in `#/my-input` does not match any given oneof schema', {
-                '#/my-input': [
-                    {
-                        data: {
-                            errors: [
-                                {
-                                    code: 'type-error',
-                                    data: { expected: 'array', pointer: '#/my-input', received: 'number', value: 123 },
-                                    message: 'Expected `123` (number) in `#/my-input` to be of type `array`',
-                                    name: 'TypeError',
-                                    type: 'error',
-                                },
-                            ],
-                            oneOf: [{ $ref: 'FormattedText.json' }],
-                            pointer: '#/my-input',
-                            value: '123',
-                        },
-                        message: 'Value `123` in `#/my-input` does not match any given oneof schema',
-                    },
-                ],
-            });
-        });
-        it('should throw an error if the FormattedText input is invalid formatted text', () => {
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const inputValue = {
-                'my-input': {
-                    something: 'aa',
-                },
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `{"something":"aa"}` in `#/my-input` does not match any given oneof schema', {
-                '#/my-input': [
-                    {
-                        data: {
-                            errors: [
-                                {
-                                    code: 'type-error',
-                                    data: { expected: 'array', pointer: '#/my-input', received: 'object', value: { something: 'aa' } },
-                                    message: 'Expected `Object {"something":"aa"}` (object) in `#/my-input` to be of type `array`',
-                                    name: 'TypeError',
-                                    type: 'error',
-                                },
-                            ],
-                            oneOf: [{ $ref: 'FormattedText.json' }],
-                            pointer: '#/my-input',
-                            value: '{"something":"aa"}',
-                        },
-                        message: 'Value `{"something":"aa"}` in `#/my-input` does not match any given oneof schema',
-                    },
-                ],
-            });
-        });
-        it('should throw an error if the FormattedText input is invalid formatted text (deeply nested)', () => {
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [
-                        { type: 'text', value: 'This is some ' },
-                        { type: 'text', value: 'Link to asset 12345' },
-                        { type: 'text', value: ' with an image ' },
-                        { type: 'text', value: 123 },
-                        { type: 'text', value: '.' },
-                    ],
-                },
-            ];
-            const inputValue = {
-                'my-input': formattedText,
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `[{"tag":"p","type":"tag","children":[{"type":"text","value":"This is some "},{"type":"text","value":"Link to asset 12345"},{"type":"text","value":" with an image "},{"type":"text","value":123},{"type":"text","value":"."}]}]` in `#/my-input` does not match any given oneof schema', {
-                '#/my-input': [
-                    {
-                        data: {
-                            errors: [
-                                {
-                                    code: 'any-of-error',
-                                    data: {
-                                        anyOf: [
-                                            { $ref: '#/definitions/HigherOrderFormattedNodes' },
-                                            { $ref: '#/definitions/BaseFormattedNodes' },
-                                        ],
-                                        pointer: '#/my-input/0',
-                                        value: {
-                                            children: [
-                                                { type: 'text', value: 'This is some ' },
-                                                { type: 'text', value: 'Link to asset 12345' },
-                                                { type: 'text', value: ' with an image ' },
-                                                { type: 'text', value: 123 },
-                                                { type: 'text', value: '.' },
-                                            ],
-                                            tag: 'p',
-                                            type: 'tag',
-                                        },
-                                    },
-                                    message: 'Object at `#/my-input/0` does not match any schema',
-                                    name: 'AnyOfError',
-                                    type: 'error',
-                                },
-                            ],
-                            oneOf: [{ $ref: 'FormattedText.json' }],
-                            pointer: '#/my-input',
-                            value: '[{"tag":"p","type":"tag","children":[{"type":"text","value":"This is some "},{"type":"text","value":"Link to asset 12345"},{"type":"text","value":" with an image "},{"type":"text","value":123},{"type":"text","value":"."}]}]',
-                        },
-                        message: 'Value `[{"tag":"p","type":"tag","children":[{"type":"text","value":"This is some "},{"type":"text","value":"Link to asset 12345"},{"type":"text","value":" with an image "},{"type":"text","value":123},{"type":"text","value":"."}]}]` in `#/my-input` does not match any given oneof schema',
-                    },
-                ],
-            });
-        });
-        it('should validate an array of formatted texts', () => {
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [{ type: 'text', value: 'hello' }],
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    arr: {
-                        type: 'array',
-                        items: { type: 'FormattedText' },
-                    },
-                },
-            };
-            const value = {
-                arr: [formattedText],
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
-        });
-        it('should throw an error if the FormattedText input is invalid formatted text (deeply, deeply nested)', () => {
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [{ type: 'text', value: 'hello' }],
-                },
-            ];
-            const inputValue = {
-                'my-input': formattedText,
-                deep: {
-                    arr: [
-                        {
-                            prop: formattedText,
-                            formattedTextArray: [formattedText, formattedText, { bad: 'data' }],
-                        },
-                    ],
-                },
-            };
-            const functionInputSchema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'FormattedText' },
-                    deep: {
-                        type: 'object',
-                        properties: {
-                            arr: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['prop', 'formattedTextArray'],
-                                    properties: {
-                                        prop: 'FormattedText',
-                                        formattedTextArray: {
-                                            type: 'array',
-                                            items: {
-                                                type: 'FormattedText',
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        required: ['arr'],
-                    },
-                },
-                required: ['my-input', 'deep'],
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `{"bad":"data"}` in `#/deep/arr/0/formattedTextArray/2` does not match any given oneof schema', {
-                '#/deep/arr/0/formattedTextArray/2': [
-                    {
-                        data: {
-                            errors: [
-                                {
-                                    code: 'type-error',
-                                    data: {
-                                        expected: 'array',
-                                        pointer: '#/deep/arr/0/formattedTextArray/2',
-                                        received: 'object',
-                                        value: { bad: 'data' },
-                                    },
-                                    message: 'Expected `Object {"bad":"data"}` (object) in `#/deep/arr/0/formattedTextArray/2` to be of type `array`',
-                                    name: 'TypeError',
-                                    type: 'error',
-                                },
-                            ],
-                            oneOf: [{ $ref: 'FormattedText.json' }],
-                            pointer: '#/deep/arr/0/formattedTextArray/2',
-                            value: '{"bad":"data"}',
-                        },
-                        message: 'Value `{"bad":"data"}` in `#/deep/arr/0/formattedTextArray/2` does not match any given oneof schema',
-                    },
-                ],
-            });
-        });
-        it('should validate a FormattedText value when the schema is a $ref', async () => {
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [{ type: 'text', value: 'hello' }],
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    'my-input': { $ref: '#/definitions/FormattedText' },
-                },
-                definitions: {
-                    FormattedText: { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const value = {
-                'my-input': formattedText,
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
-        });
-        it('should error when a FormattedText value is invalid when the schema is a $ref', async () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    'my-input': { $ref: '#/definitions/FormattedText' },
-                },
-                definitions: {
-                    FormattedText: { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const value = {
-                'my-input': { bad: 'data' },
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(value, schema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `{"bad":"data"}` in `#/my-input` does not match any given oneof schema', {
-                '#/my-input': [
-                    {
-                        data: {
-                            errors: [
-                                {
-                                    code: 'type-error',
-                                    data: { expected: 'array', pointer: '#/my-input', received: 'object', value: { bad: 'data' } },
-                                    message: 'Expected `Object {"bad":"data"}` (object) in `#/my-input` to be of type `array`',
-                                    name: 'TypeError',
-                                    type: 'error',
-                                },
-                            ],
-                            oneOf: [{ $ref: 'FormattedText.json' }],
-                            pointer: '#/my-input',
-                            value: '{"bad":"data"}',
-                        },
-                        message: 'Value `{"bad":"data"}` in `#/my-input` does not match any given oneof schema',
-                    },
-                ],
-            });
-        });
-        it('should validate a FormattedText value when the schema is a $ref to a $ref', async () => {
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [{ type: 'text', value: 'hello' }],
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    'my-input': { $ref: '#/definitions/FormattedText' },
-                },
-                definitions: {
-                    FormattedText: { $ref: '#/definitions/FormattedText2' },
-                    FormattedText2: { type: 'FormattedText' },
-                },
-                required: ['my-input'],
-            };
-            const value = {
-                'my-input': formattedText,
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
-        });
-        it('should validate a FormattedText value when the schema is in an if/then/else', async () => {
-            const formattedText = [
-                {
-                    tag: 'p',
-                    type: 'tag',
-                    children: [{ type: 'text', value: 'hello' }],
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    'my-input': {
-                        if: { type: 'string' },
-                        then: { type: 'string' },
-                        else: { type: 'FormattedText' },
-                    },
-                },
-                required: ['my-input'],
-            };
-            const value = {
-                'my-input': formattedText,
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
-        });
-        it('should allow an empty array', async () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    'my-input': { type: 'FormattedText' },
-                },
-                required: [],
-            };
-            expect(jsonSchemaService.validateInput({ 'my-input': [] }, schema)).toEqual(true);
-        });
-        it.each([
-            ['with attributes', { title: 'Link title' }],
-            ['without attributes', undefined],
-        ])('should validate link-to-matrix-asset - %s', (_, attributes) => {
-            const formattedText = [
-                {
-                    type: 'link-to-matrix-asset',
-                    matrixIdentifier: 'matrix-identifier',
-                    matrixDomain: 'https://matrix-api-url',
-                    target: '_blank',
-                    matrixAssetId: '12345',
-                    children: [{ type: 'text', value: 'hello' }],
-                    attributes,
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    myInput: {
-                        type: 'FormattedText',
-                    },
-                },
-            };
-            const value = {
-                myInput: formattedText,
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toBe(true);
-        });
-        it('should throw if link-to-matrix-asset contains a reserved attribute', () => {
-            const formattedText = [
-                {
-                    type: 'link-to-matrix-asset',
-                    matrixIdentifier: 'matrix-identifier',
-                    matrixDomain: 'https://matrix-api-url',
-                    target: '_blank',
-                    matrixAssetId: '12345',
-                    children: [{ type: 'text', value: 'hello' }],
-                    attributes: {
-                        // href is reserved (resolved from the selected Matrix asset)
-                        href: 'https://www.my-matrix.squiz.net',
-                    },
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    myInput: {
-                        type: 'FormattedText',
-                    },
-                },
-            };
-            const value = {
-                myInput: formattedText,
-            };
-            expect(() => jsonSchemaService.validateInput(value, schema)).toThrow(/does not match any given oneof schema/);
-        });
-        it.each([
-            ['with attributes', { title: 'Link title' }],
-            ['without attributes', undefined],
-        ])('should validate matrix-image - %s', (_, attributes) => {
-            const formattedText = [
-                {
-                    type: 'matrix-image',
-                    matrixIdentifier: 'matrix-identifier',
-                    matrixDomain: 'https://matrix-api-url',
-                    matrixAssetId: '12345',
-                    attributes,
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    myInput: {
-                        type: 'FormattedText',
-                    },
-                },
-            };
-            const value = {
-                myInput: formattedText,
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toBe(true);
-        });
-        it('should throw if matrix-image contains a reserved attribute', () => {
-            const formattedText = [
-                {
-                    type: 'matrix-image',
-                    matrixIdentifier: 'matrix-identifier',
-                    matrixDomain: 'https://matrix-api-url',
-                    matrixAssetId: '12345',
-                    attributes: {
-                        // src is reserved (resolved from the selected Matrix asset)
-                        src: 'https://www.my-matrix.squiz.net/image.png',
-                    },
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    myInput: {
-                        type: 'FormattedText',
-                    },
-                },
-            };
-            const value = {
-                myInput: formattedText,
-            };
-            expect(() => jsonSchemaService.validateInput(value, schema)).toThrow(/does not match any given oneof schema/);
-        });
-        it.each([
-            ['with attributes', { title: 'Link title' }],
-            ['without attributes', undefined],
-        ])('should validate dam-image - %s', (_, attributes) => {
-            const formattedText = [
-                {
-                    type: 'dam-image',
-                    damSystemIdentifier: 'dam-identifier',
-                    damObjectId: '12345',
-                    damSystemType: 'bynder',
-                    attributes,
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    myInput: {
-                        type: 'FormattedText',
-                    },
-                },
-            };
-            const value = {
-                myInput: formattedText,
-            };
-            expect(jsonSchemaService.validateInput(value, schema)).toBe(true);
-        });
-        it('should throw if dam-image contains a reserved attribute', () => {
-            const formattedText = [
-                {
-                    type: 'dam-image',
-                    damSystemIdentifier: 'dam-identifier',
-                    damObjectId: '12345',
-                    damSystemType: 'bynder',
-                    attributes: {
-                        // src is reserved (resolved from the selected DAM asset)
-                        src: 'https://www.my-matrix.squiz.net/image.png',
-                    },
-                },
-            ];
-            const schema = {
-                type: 'object',
-                properties: {
-                    myInput: {
-                        type: 'FormattedText',
-                    },
-                },
-            };
-            const value = {
-                myInput: formattedText,
-            };
-            expect(() => jsonSchemaService.validateInput(value, schema)).toThrow(/does not match any given oneof schema/);
-        });
-    });
-    describe('standard inputs', () => {
-        const functionInputSchema = {
-            type: 'object',
-            properties: {
-                'my-input': { type: 'number' },
-            },
-            required: ['my-input'],
-        };
-        it('should return true for valid input values', () => {
-            const inputValue = {
-                'my-input': 123,
-            };
-            const result = jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            expect(result).toBe(true);
-        });
-        it('should throw a SchemaValidationError for invalid input type', () => {
-            const inputValue = {
-                'my-input': '123',
-            };
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }, SchemaValidationError_1.SchemaValidationError, `failed validation: Expected \`123\` (string) in \`#/my-input\` to be of type \`number\``, {
-                '#/my-input': [
-                    {
-                        data: { expected: 'number', pointer: '#/my-input', received: 'string', value: '123' },
-                        message: 'Expected `123` (string) in `#/my-input` to be of type `number`',
-                    },
-                ],
-            });
-        });
-        it('should throw a SchemaValidationError for invalid input missing properties', () => {
-            const inputValue = {};
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }, SchemaValidationError_1.SchemaValidationError, `failed validation: The required property \`my-input\` is missing at \`#\``, {
-                '#': [
-                    { data: { key: 'my-input', pointer: '#' }, message: 'The required property `my-input` is missing at `#`' },
-                ],
-            });
-        });
-        it('should throw a SchemaValidationError with a truncated enum value list if there are more than 5 enum options', () => {
-            expectToThrowErrorMatchingTypeAndMessage(() => {
-                jsonSchemaService.validateInput({ enum: 'z' }, { type: 'object', properties: { enum: { type: 'string', enum: ['a', 'b', 'c', 'd', 'e', 'f', 'g'] } } });
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected given value `z` in #/enum` to be one of `[a, b, c, d, e, ... 2 more]`', {
-                '#/enum': [
-                    {
-                        data: { pointer: '#/enum', value: 'z', values: ['a', 'b', 'c', 'd', 'e', 'f', 'g'] },
-                        message: 'Expected given value `z` in #/enum` to be one of `[a, b, c, d, e, ... 2 more]`',
-                    },
-                ],
-            });
-        });
-        // TODO DEVX-658
-        it.skip('should throw a SchemaValidationError for invalid input additional properties', () => {
-            const inputValue = {
-                'my-input': 123,
-                'my-input-2': 123,
-            };
-            expect(() => {
-                jsonSchemaService.validateInput(inputValue, functionInputSchema);
-            }).toThrowErrorMatchingInlineSnapshot();
-        });
-    });
-    describe('validateInput', () => {
-        it.each([String('123'), Number(123), [123]])('should validate any primitive type with its resolvable type %s', (propertyValue) => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const MyResolvableNumber = resolvableTypeFixture('MyResolvableNumber', { type: 'number' });
-            const MyResolvableArray = resolvableTypeFixture('MyResolvableArray', { type: 'array' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableNumber: (value) => value.toString(),
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableArray: (value) => value.join(''),
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            expect(jsonSchemaService.validateInput({ myProperty: propertyValue }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } })).toEqual(true);
-        });
-        it('should error when a primitive type is provided a value that cannot be resolved by its resolvable types', () => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const MyResolvableNumber = resolvableTypeFixture('MyResolvableNumber', { type: 'number' });
-            const MyResolvableArray = resolvableTypeFixture('MyResolvableArray', { type: 'array' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableNumber: (value) => value.toString(),
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableArray: (value) => value.join(''),
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            expect(() => {
-                jsonSchemaService.validateInput({ myProperty: true }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } });
-            }).toThrowError();
-        });
-        it.each([String('123'), Number(123), [123]])('should validate a primitive type when defined as a ref with resolvable value %s', (propertyValue) => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const MyResolvableNumber = resolvableTypeFixture('MyResolvableNumber', { type: 'number' });
-            const MyResolvableArray = resolvableTypeFixture('MyResolvableArray', { type: 'array' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableNumber: (value) => value.toString(),
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableArray: (value) => value.join(''),
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            expect(jsonSchemaService.validateInput({ myProperty: propertyValue }, {
-                type: 'object',
-                properties: { myProperty: { $ref: '#/definitions/Ref' } },
-                definitions: { Ref: { type: 'MyPrimitive' } },
-            })).toEqual(true);
-        });
-        it('should not validate on a primitive type against a resolvable type when a resolver is not defined', () => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const MyResolvableNumber = resolvableTypeFixture('MyResolvableNumber', { type: 'number' });
-            const MyResolvableArray = resolvableTypeFixture('MyResolvableArray', { type: 'array' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableNumber: (value) => value.toString(),
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            expect(() => {
-                jsonSchemaService.validateInput({ myProperty: [123] }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } });
-            }).toThrowError();
-        });
-        it('should validate a primitive type against similar but different resolvable types', () => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [
-                resolvableTypeFixture('MyResolvableSrcNumber', {
-                    type: 'object',
-                    properties: {
-                        src: { type: 'number' },
-                    },
-                }),
-                resolvableTypeFixture('MyResolvableSrcString', {
-                    type: 'object',
-                    properties: {
-                        src: { type: 'string' },
-                    },
-                }),
-            ], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableSrcNumber: (value) => value.src.toString(),
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableSrcString: (value) => value.src,
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            expect(jsonSchemaService.validateInput({
-                myProperty: {
-                    src: 123,
-                },
-            }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } })).toEqual(true);
-            expect(jsonSchemaService.validateInput({
-                myProperty: {
-                    src: '123',
-                },
-            }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } })).toEqual(true);
-        });
-    });
-    describe('resolveInput', () => {
-        it.each([String('123'), Number(123), [123]])('should resolve a primitive type from its resolvable type %s', async (resolvableValue) => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [
-                resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-                resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            ], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableNumber: (value) => value.toString(),
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableArray: (value) => value.join(''),
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            await expect(jsonSchemaService.resolveInput({ myProperty: resolvableValue }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } })).resolves.toEqual({ myProperty: '123' });
-        });
-        it.each([
-            [{ src: 'MyString' }, 'MyString'],
-            [{ src: 1132 }, '1132'],
-        ])('should resolve a resolvable type %s against the correct resolver to %s', async (resolvableValue, output) => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [
-                resolvableTypeFixture('MyResolvableSrcString', {
-                    type: 'object',
-                    properties: { src: { type: 'string' } },
-                }),
-                resolvableTypeFixture('MyResolvableSrcNumber', {
-                    type: 'object',
-                    properties: { src: { type: 'number' } },
-                }),
-            ], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableSrcNumber: (value) => value.src.toString(),
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableSrcString: (value) => value.src,
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            await expect(jsonSchemaService.resolveInput({ myProperty: resolvableValue }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } })).resolves.toEqual({ myProperty: output });
-        });
-        it('should resolve a primitive type from its resolvable type %s', async () => {
-            const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [resolvableTypeFixture('MyResolvableWithError', { type: 'number' })], {
-                MyPrimitive: {
-                    // @ts-expect-error - fixture is unknown but we know the actual shape
-                    MyResolvableWithError: (_value) => {
-                        throw new Error('Failed resolving!!');
-                    },
-                },
-            }), JsonValidationService_1.ComponentInputMetaSchema);
-            await expect(jsonSchemaService.resolveInput({ myProperty: 123, myProperty2: 234 }, { type: 'object', properties: { myProperty: { type: 'MyPrimitive' }, myProperty2: { type: 'MyPrimitive' } } })).rejects.toThrowErrorMatchingInlineSnapshot(`
-        "Error(s) occurred when resolving JSON:
-        Error: Error resolving JSON at #/myProperty: Failed resolving!!
-        Error: Error resolving JSON at #/myProperty2: Failed resolving!!"
-      `);
-        });
-        it('should resolve a FormattedText empty list', async () => {
-            const types = TypeResolverBuilder_1.TypeResolverBuilder.new().addPrimitive(primitiveTypes_1.FormattedTextType).build();
-            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(types, JsonValidationService_1.ComponentInputMetaSchema);
-            await expect(jsonSchemaService.resolveInput({ myProp: [] }, { type: 'object', properties: { myProp: { type: 'FormattedText' } }, required: [] })).resolves.toEqual({ myProp: [] });
-        });
-    });
-});
-describe('JSONSchemaService - validation', () => {
-    const typeResolver = TypeResolverBuilder_1.TypeResolverBuilder.new()
-        .addPrimitive(primitiveTypes_1.SquizImageType)
-        .addPrimitive(primitiveTypes_1.SquizLinkType)
-        .addPrimitive(primitiveTypes_1.FormattedTextType)
-        .build();
-    const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-    it('should validate a schema with all the squiz primitive types', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                image: { type: 'SquizImage' },
-                link: { type: 'SquizLink' },
-                text: { type: 'FormattedText' },
-            },
-            required: ['image', 'link', 'text'],
-        };
-        const formattedText = [
-            {
-                tag: 'p',
-                type: 'tag',
-                children: [{ type: 'text', value: 'hello' }],
-            },
-        ];
-        const input = {
-            image: {
-                name: 'test-image.jpeg',
-                imageVariations: {
-                    original: {
-                        aspectRatio: '1:1',
-                        height: 100,
-                        width: 100,
-                        url: 'https://www.squiz.net',
-                        byteSize: 100,
-                        mimeType: 'image/jpeg',
-                        sha1Hash: '123',
-                    },
-                },
-            },
-            link: {
-                text: 'test-link',
-                url: 'https://www.squiz.net',
-                target: '_blank',
-            },
-            text: formattedText,
-        };
-        const result = jsonSchemaService.validateInput(input, schema);
-        expect(result).toEqual(true);
-    });
-    it('should validate a schema with all the squiz primitive types and matrix-asset-uri format', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                image: { type: 'SquizImage' },
-                link: { type: 'SquizLink' },
-                text: { type: 'FormattedText' },
-                asset: {
-                    type: 'string',
-                    format: 'matrix-asset-uri',
-                },
-            },
-            required: ['image', 'link', 'text', 'asset'],
-        };
-        const formattedText = [
-            {
-                tag: 'p',
-                type: 'tag',
-                children: [{ type: 'text', value: 'hello' }],
-            },
-        ];
-        const input = {
-            image: {
-                name: 'test-image.jpeg',
-                imageVariations: {
-                    original: {
-                        aspectRatio: '1:1',
-                        height: 100,
-                        width: 100,
-                        url: 'https://www.squiz.net',
-                        byteSize: 100,
-                        mimeType: 'image/jpeg',
-                        sha1Hash: '123',
-                    },
-                },
-            },
-            link: {
-                text: 'test-link',
-                url: 'https://www.squiz.net',
-                target: '_blank',
-            },
-            text: formattedText,
-            asset: 'matrix-asset://identifier/123',
-        };
-        const result = jsonSchemaService.validateInput(input, schema);
-        expect(result).toEqual(true);
-    });
-    it('should catch validation errors when there is a schema with all the squiz primitive types', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                image: { type: 'SquizImage' },
-                link: { type: 'SquizLink' },
-                text: { type: 'FormattedText' },
-            },
-            required: ['image', 'link', 'text'],
-        };
-        const formattedText = [
-            //@ts-expect-error - wrong type
-            {
-                children: [{ type: 'text', value: 'hello' }],
-            },
-        ];
-        const input = {
-            image: {
-                name: 'test-image.jpeg',
-                imageVariations: {
-                    //@ts-expect-error - wrong type
-                    original: {
-                        width: 100,
-                        url: 'https://www.squiz.net',
-                        byteSize: 100,
-                        mimeType: 'image/jpeg',
-                        sha1Hash: '123',
-                    },
-                },
-            },
-            //@ts-expect-error - wrong type
-            link: {
-                text: 'test-link',
-                target: '_blank',
-            },
-            text: formattedText,
-        };
-        expectToThrowErrorMatchingTypeAndMessage(() => jsonSchemaService.validateInput(input, schema), SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `{"name":"test-image.jpeg","imageVariations":{"original":{"width":100,"url":"https://www.squiz.net","byteSize":100,"mimeType":"image/jpeg","sha1Hash":"123"}}}` in `#/image` does not match any given oneof schema,\nValue `{"text":"test-link","target":"_blank"}` in `#/link` does not match any given oneof schema,\nValue `[{"children":[{"type":"text","value":"hello"}]}]` in `#/text` does not match any given oneof schema', {
-            '#/image': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'height', pointer: '#/image/imageVariations/original' },
-                                message: 'The required property `height` is missing at `#/image/imageVariations/original`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'aspectRatio', pointer: '#/image/imageVariations/original' },
-                                message: 'The required property `aspectRatio` is missing at `#/image/imageVariations/original`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'SquizImage.json' }],
-                        pointer: '#/image',
-                        value: '{"name":"test-image.jpeg","imageVariations":{"original":{"width":100,"url":"https://www.squiz.net","byteSize":100,"mimeType":"image/jpeg","sha1Hash":"123"}}}',
-                    },
-                    message: 'Value `{"name":"test-image.jpeg","imageVariations":{"original":{"width":100,"url":"https://www.squiz.net","byteSize":100,"mimeType":"image/jpeg","sha1Hash":"123"}}}` in `#/image` does not match any given oneof schema',
-                },
-            ],
-            '#/link': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'url', pointer: '#/link' },
-                                message: 'The required property `url` is missing at `#/link`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'SquizLink.json' }],
-                        pointer: '#/link',
-                        value: '{"text":"test-link","target":"_blank"}',
-                    },
-                    message: 'Value `{"text":"test-link","target":"_blank"}` in `#/link` does not match any given oneof schema',
-                },
-            ],
-            '#/text': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'any-of-error',
-                                data: {
-                                    anyOf: [
-                                        { $ref: '#/definitions/HigherOrderFormattedNodes' },
-                                        { $ref: '#/definitions/BaseFormattedNodes' },
-                                    ],
-                                    pointer: '#/text/0',
-                                    value: { children: [{ type: 'text', value: 'hello' }] },
-                                },
-                                message: 'Object at `#/text/0` does not match any schema',
-                                name: 'AnyOfError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'FormattedText.json' }],
-                        pointer: '#/text',
-                        value: '[{"children":[{"type":"text","value":"hello"}]}]',
-                    },
-                    message: 'Value `[{"children":[{"type":"text","value":"hello"}]}]` in `#/text` does not match any given oneof schema',
-                },
-            ],
-        });
-    });
-    it('should catch validation errors when invalid matrix-asset-uri is provided with invalid other squiz primitive types ', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                image: { type: 'SquizImage' },
-                link: { type: 'SquizLink' },
-                text: { type: 'FormattedText' },
-                asset: {
-                    type: 'string',
-                    format: 'matrix-asset-uri',
-                },
-            },
-            required: ['image', 'link', 'text', 'asset'],
-        };
-        const formattedText = [
-            //@ts-expect-error - wrong type
-            {
-                children: [{ type: 'text', value: 'hello' }],
-            },
-        ];
-        const input = {
-            image: {
-                name: 'test-image.jpeg',
-                imageVariations: {
-                    //@ts-expect-error - wrong type
-                    original: {
-                        width: 100,
-                        url: 'https://www.squiz.net',
-                        byteSize: 100,
-                        mimeType: 'image/jpeg',
-                        sha1Hash: '123',
-                    },
-                },
-            },
-            //@ts-expect-error - wrong type
-            link: {
-                text: 'test-link',
-                target: '_blank',
-            },
-            text: formattedText,
-            // @ts-expect-error - wrong type
-            asset: 'matrix://123',
-        };
-        expectToThrowErrorMatchingTypeAndMessage(() => jsonSchemaService.validateInput(input, schema), SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `{"name":"test-image.jpeg","imageVariations":{"original":{"width":100,"url":"https://www.squiz.net","byteSize":100,"mimeType":"image/jpeg","sha1Hash":"123"}}}` in `#/image` does not match any given oneof schema,\nValue `{"text":"test-link","target":"_blank"}` in `#/link` does not match any given oneof schema,\nValue `[{"children":[{"type":"text","value":"hello"}]}]` in `#/text` does not match any given oneof schema,\nValue matrix-asset-uri (matrix://123) in `#/asset` is not a valid matrix asset uri', {
-            '#/asset': [
-                {
-                    data: {
-                        errors: {
-                            assetId: {
-                                data: { expected: /^\d+(?::.+)?$/, received: '' },
-                                message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
-                            },
-                            scheme: {
-                                data: { expected: 'matrix-asset', received: 'matrix' },
-                                message: 'Uri scheme is invalid, must match "matrix-asset"',
-                            },
-                        },
-                        pointer: '#/asset',
-                        value: 'matrix://123',
-                    },
-                    message: 'Value matrix-asset-uri (matrix://123) in `#/asset` is not a valid matrix asset uri',
-                },
-            ],
-            '#/image': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'height', pointer: '#/image/imageVariations/original' },
-                                message: 'The required property `height` is missing at `#/image/imageVariations/original`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'aspectRatio', pointer: '#/image/imageVariations/original' },
-                                message: 'The required property `aspectRatio` is missing at `#/image/imageVariations/original`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'SquizImage.json' }],
-                        pointer: '#/image',
-                        value: '{"name":"test-image.jpeg","imageVariations":{"original":{"width":100,"url":"https://www.squiz.net","byteSize":100,"mimeType":"image/jpeg","sha1Hash":"123"}}}',
-                    },
-                    message: 'Value `{"name":"test-image.jpeg","imageVariations":{"original":{"width":100,"url":"https://www.squiz.net","byteSize":100,"mimeType":"image/jpeg","sha1Hash":"123"}}}` in `#/image` does not match any given oneof schema',
-                },
-            ],
-            '#/link': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'url', pointer: '#/link' },
-                                message: 'The required property `url` is missing at `#/link`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'SquizLink.json' }],
-                        pointer: '#/link',
-                        value: '{"text":"test-link","target":"_blank"}',
-                    },
-                    message: 'Value `{"text":"test-link","target":"_blank"}` in `#/link` does not match any given oneof schema',
-                },
-            ],
-            '#/text': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'any-of-error',
-                                data: {
-                                    anyOf: [
-                                        { $ref: '#/definitions/HigherOrderFormattedNodes' },
-                                        { $ref: '#/definitions/BaseFormattedNodes' },
-                                    ],
-                                    pointer: '#/text/0',
-                                    value: { children: [{ type: 'text', value: 'hello' }] },
-                                },
-                                message: 'Object at `#/text/0` does not match any schema',
-                                name: 'AnyOfError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'FormattedText.json' }],
-                        pointer: '#/text',
-                        value: '[{"children":[{"type":"text","value":"hello"}]}]',
-                    },
-                    message: 'Value `[{"children":[{"type":"text","value":"hello"}]}]` in `#/text` does not match any given oneof schema',
-                },
-            ],
-        });
-    });
-    it('should validate when MatrixAssetType is being used for a squiz primitive type with resolver', () => {
-        const typeResolver = TypeResolverBuilder_1.TypeResolverBuilder.new()
-            .addPrimitive(primitiveTypes_1.SquizImageType)
-            .addPrimitive(primitiveTypes_1.SquizLinkType)
-            .addPrimitive(primitiveTypes_1.FormattedTextType)
-            .addResolver(primitiveTypes_1.SquizImageType, resolvableTypes_1.MatrixAssetType, () => {
-            return {
-                name: '',
-                imageVariations: {
-                    original: {
-                        width: 0,
-                        height: 0,
-                        url: '',
-                        mimeType: '',
-                        byteSize: 0,
-                        sha1Hash: '',
-                        aspectRatio: '',
-                    },
-                },
-            };
-        })
-            .build();
-        const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-        const schema = {
-            type: 'object',
-            properties: {
-                image: { type: 'SquizImage' },
-                link: { type: 'SquizLink' },
-                text: { type: 'FormattedText' },
-                asset: {
-                    type: 'string',
-                    format: 'matrix-asset-uri',
-                },
-            },
-            required: ['image', 'link', 'text', 'asset'],
-        };
-        const formattedText = [
-            {
-                tag: 'p',
-                type: 'tag',
-                children: [{ type: 'text', value: 'hello' }],
-            },
-        ];
-        const input = {
-            image: {
-                matrixAssetId: '123',
-                matrixIdentifier: 'identifier',
-                matrixDomain: 'domain',
-            },
-            link: {
-                text: 'test-link',
-                url: 'https://www.squiz.net',
-                target: '_blank',
-            },
-            text: formattedText,
-            asset: 'matrix-asset://identifier/123',
-        };
-        expect(jsonSchemaService.validateInput(input, schema)).toEqual(true);
-    });
-    it('it should catch MatrixAssetType validation errors when being use for squiz primitive type with resolver', () => {
-        const typeResolver = TypeResolverBuilder_1.TypeResolverBuilder.new()
-            .addPrimitive(primitiveTypes_1.SquizImageType)
-            .addPrimitive(primitiveTypes_1.SquizLinkType)
-            .addPrimitive(primitiveTypes_1.FormattedTextType)
-            .addResolver(primitiveTypes_1.SquizImageType, resolvableTypes_1.MatrixAssetType, () => {
-            return {
-                name: '',
-                imageVariations: {
-                    original: {
-                        width: 0,
-                        height: 0,
-                        url: '',
-                        mimeType: '',
-                        byteSize: 0,
-                        sha1Hash: '',
-                        aspectRatio: '',
-                    },
-                },
-            };
-        })
-            .build();
-        const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-        const schema = {
-            type: 'object',
-            properties: {
-                image: { type: 'SquizImage' },
-            },
-            required: ['image'],
-        };
-        const input = {
-            //@ts-expect-error - intentionally invalid input
-            image: {
-                matrixIdentifier: 'identifier',
-            },
-        };
-        expectToThrowErrorMatchingTypeAndMessage(() => jsonSchemaService.validateInput(input, schema), SchemaValidationError_1.SchemaValidationError, 'failed validation: Value `{"matrixIdentifier":"identifier"}` in `#/image` does not match any given oneof schema', {
-            '#/image': [
-                {
-                    data: {
-                        errors: [
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'name', pointer: '#/image' },
-                                message: 'The required property `name` is missing at `#/image`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'imageVariations', pointer: '#/image' },
-                                message: 'The required property `imageVariations` is missing at `#/image`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                            {
-                                code: 'required-property-error',
-                                data: { key: 'matrixAssetId', pointer: '#/image' },
-                                message: 'The required property `matrixAssetId` is missing at `#/image`',
-                                name: 'RequiredPropertyError',
-                                type: 'error',
-                            },
-                        ],
-                        oneOf: [{ $ref: 'SquizImage.json' }, { $ref: 'MatrixAsset.json' }],
-                        pointer: '#/image',
-                        value: '{"matrixIdentifier":"identifier"}',
-                    },
-                    message: 'Value `{"matrixIdentifier":"identifier"}` in `#/image` does not match any given oneof schema',
-                },
-            ],
-        });
-    });
-    it('should only resolve an array of items containing resolvable types, other arrays are unaffected', async () => {
-        const typeResolver = TypeResolverBuilder_1.TypeResolverBuilder.new()
-            .addPrimitive(primitiveTypes_1.SquizImageType)
-            .addPrimitive(primitiveTypes_1.SquizLinkType)
-            .addPrimitive(primitiveTypes_1.FormattedTextType)
-            .addResolver(primitiveTypes_1.SquizImageType, resolvableTypes_1.MatrixAssetType, () => {
-            return {
-                name: '',
-                imageVariations: {
-                    original: {
-                        width: 0,
-                        height: 0,
-                        url: '',
-                        mimeType: '',
-                        byteSize: 0,
-                        sha1Hash: '',
-                        aspectRatio: '',
-                    },
-                },
-            };
-        })
-            .addResolver(primitiveTypes_1.SquizLinkType, resolvableTypes_1.MatrixAssetLinkType, () => {
-            return {
-                text: 'link text',
-                url: 'www.test.com',
-                target: '_self',
-            };
-        })
-            .build();
-        const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-        const schema = {
-            type: 'object',
-            properties: {
-                images: {
-                    description: 'Gallery images',
-                    type: 'array',
-                    items: {
-                        type: 'SquizImage',
-                    },
-                },
-                squizLink: {
-                    title: 'Squiz link',
-                    type: 'array',
-                    items: {
-                        type: 'SquizLink',
-                    },
-                },
-                //custom format
-                multiLine: {
-                    title: 'Multi-line (textarea)',
-                    type: 'array',
-                    items: {
-                        type: 'string',
-                        format: 'multi-line',
-                    },
-                },
-                //string array
-                listOfStrings: {
-                    type: 'array',
-                    title: 'A list of strings',
-                    items: {
-                        type: 'string',
-                        default: 'Holy smokes',
-                    },
-                },
-            },
-            required: ['images', 'links'],
-        };
-        const input = {
-            images: [
-                {
-                    matrixDomain: 'https://feaas-page-render-us.dev.matrix.squiz.cloud/59',
-                    matrixAssetId: '160',
-                    matrixIdentifier: 'feaas-matrix-us',
-                },
-            ],
-            squizLink: [
-                {
-                    matrixDomain: 'https://feaas-page-render-us.dev.matrix.squiz.cloud/59',
-                    matrixAssetId: '160',
-                    matrixIdentifier: 'feaas-matrix-us',
-                    target: '_self',
-                },
-            ],
-            multiline: ['wow', 'much', 'multiline'],
-            listOfStrings: ['very', 'string'],
-        };
-        const result = await jsonSchemaService.resolveInput(input, schema);
-        expect(result).toEqual({
-            images: [
-                {
-                    imageVariations: {
-                        original: { aspectRatio: '', byteSize: 0, height: 0, mimeType: '', sha1Hash: '', url: '', width: 0 },
-                    },
-                    name: '',
-                },
-            ],
-            squizLink: [
-                {
-                    text: 'link text',
-                    url: 'www.test.com',
-                    target: '_self',
-                },
-            ],
-            multiline: ['wow', 'much', 'multiline'],
-            listOfStrings: ['very', 'string'],
-        });
-    });
-    it('should resolve multiple primitive type array items in multi-level nested array structures', async () => {
-        const typeResolver = TypeResolverBuilder_1.TypeResolverBuilder.new()
-            .addPrimitive(primitiveTypes_1.SquizLinkType)
-            .addResolver(primitiveTypes_1.SquizLinkType, resolvableTypes_1.MatrixAssetLinkType, (input) => {
-            if ('matrixIdentifier' in input) {
-                return {
-                    text: 'link text',
-                    url: `www.test.com/asset/${input.matrixAssetId}`,
-                    target: input.target,
-                };
-            }
-            return input;
-        })
-            .build();
-        const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-        const schema = {
-            type: 'object',
-            properties: {
-                object1: {
-                    type: 'object',
-                    required: [],
-                    properties: {
-                        array1: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    linksArray: {
-                                        type: 'array',
-                                        items: {
-                                            type: 'SquizLink',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        const input = {
-            object1: {
-                array1: [
-                    {
-                        linksArray: [
-                            {
-                                url: '#LineOne',
-                                text: 'Link One',
-                                target: '_blank',
-                            },
-                            {
-                                url: '#LineTwo',
-                                text: 'Link Two',
-                                target: '_blank',
-                            },
-                            {
-                                matrixAssetId: '100',
-                                matrixDomain: 'my-matrix.squiz.net',
-                                matrixIdentifier: 'my-matrix-identifier',
-                                target: '_blank',
-                            },
-                        ],
-                    },
-                ],
-            },
-        };
-        const result = await jsonSchemaService.resolveInput(input, schema);
-        expect(result).toEqual({
-            object1: {
-                array1: [
-                    {
-                        linksArray: [
-                            {
-                                url: '#LineOne',
-                                text: 'Link One',
-                                target: '_blank',
-                            },
-                            {
-                                url: '#LineTwo',
-                                text: 'Link Two',
-                                target: '_blank',
-                            },
-                            {
-                                url: 'www.test.com/asset/100',
-                                text: 'link text',
-                                target: '_blank',
-                            },
-                        ],
-                    },
-                ],
-            },
-        });
-    });
-    it('should not use the resolver for primitive items in a resolvable array', async () => {
-        const mockMatrixAssetResolver = jest.fn((input) => {
-            return {
-                name: input.matrixAssetId,
-                imageVariations: {
-                    original: {
-                        width: 0,
-                        height: 0,
-                        url: '',
-                        mimeType: '',
-                        byteSize: 0,
-                        sha1Hash: '',
-                        aspectRatio: '',
-                    },
-                },
-            };
-        });
-        const mockMatrixLinkResolver = jest.fn((input) => {
-            return {
-                text: input.matrixAssetId,
-                url: 'www.test.com',
-                target: '_self',
-            };
-        });
-        const typeResolver = TypeResolverBuilder_1.TypeResolverBuilder.new()
-            .addPrimitive(primitiveTypes_1.SquizImageType)
-            .addPrimitive(primitiveTypes_1.SquizLinkType)
-            .addPrimitive(primitiveTypes_1.FormattedTextType)
-            .addResolver(primitiveTypes_1.SquizImageType, resolvableTypes_1.MatrixAssetType, mockMatrixAssetResolver)
-            .addResolver(primitiveTypes_1.SquizLinkType, resolvableTypes_1.MatrixAssetLinkType, mockMatrixLinkResolver)
-            .build();
-        const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(typeResolver, JsonValidationService_1.ComponentInputMetaSchema);
-        const schema = {
-            type: 'object',
-            properties: {
-                images: {
-                    description: 'Gallery images',
-                    type: 'array',
-                    items: {
-                        type: 'SquizImage',
-                    },
-                },
-                squizLink: {
-                    title: 'Squiz link',
-                    type: 'array',
-                    items: {
-                        type: 'SquizLink',
-                    },
-                },
-                //custom format
-                multiLine: {
-                    title: 'Multi-line (textarea)',
-                    type: 'array',
-                    items: {
-                        type: 'string',
-                        format: 'multi-line',
-                    },
-                },
-                //string array
-                listOfStrings: {
-                    type: 'array',
-                    title: 'A list of strings',
-                    items: {
-                        type: 'string',
-                        default: 'Holy smokes',
-                    },
-                },
-            },
-            required: ['images', 'links'],
-        };
-        const input = {
-            images: [
-                {
-                    matrixDomain: 'https://feaas-page-render-us.dev.matrix.squiz.cloud/59',
-                    matrixAssetId: '160',
-                    matrixIdentifier: 'feaas-matrix-us',
-                },
-                {
-                    imageVariations: {
-                        original: { aspectRatio: '', byteSize: 0, height: 0, mimeType: '', sha1Hash: '', url: '', width: 0 },
-                    },
-                    name: '',
-                },
-            ],
-            squizLink: [
-                {
-                    matrixDomain: 'https://feaas-page-render-us.dev.matrix.squiz.cloud/59',
-                    matrixAssetId: '160',
-                    matrixIdentifier: 'feaas-matrix-us',
-                    target: '_self',
-                },
-                {
-                    text: 'link text',
-                    url: 'www.test.com',
-                    target: '_self',
-                },
-            ],
-            multiline: ['wow', 'much', 'multiline'],
-            listOfStrings: ['very', 'string'],
-        };
-        const result = await jsonSchemaService.resolveInput(input, schema);
-        expect(result).toEqual({
-            images: [
-                {
-                    imageVariations: {
-                        original: { aspectRatio: '', byteSize: 0, height: 0, mimeType: '', sha1Hash: '', url: '', width: 0 },
-                    },
-                    name: input.images[0].matrixAssetId,
-                },
-                {
-                    imageVariations: {
-                        original: { aspectRatio: '', byteSize: 0, height: 0, mimeType: '', sha1Hash: '', url: '', width: 0 },
-                    },
-                    name: '',
-                },
-            ],
-            squizLink: [
-                {
-                    text: input.squizLink[0].matrixAssetId,
-                    url: 'www.test.com',
-                    target: '_self',
-                },
-                {
-                    text: 'link text',
-                    url: 'www.test.com',
-                    target: '_self',
-                },
-            ],
-            multiline: ['wow', 'much', 'multiline'],
-            listOfStrings: ['very', 'string'],
-        });
-        expect(mockMatrixAssetResolver).toHaveBeenCalledTimes(1);
-        expect(mockMatrixLinkResolver).toHaveBeenCalledTimes(1);
-    });
-});
 //# sourceMappingURL=JsonValidationService.spec.js.map