@squiz/dx-json-schema-lib 1.21.1-alpha.2 → 1.21.1-alpha.21

package/lib/JsonValidationService.spec.js

@@ -7,7 +7,9 @@ const JsonValidationService_1 = require("./JsonValidationService");
 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 arbitraryTypeResolution_1 = require("./jsonTypeResolution/arbitraryTypeResolution");
+const inputStringWithFormat_json_1 = __importDefault(require("./manifest/v1/__test__/schemas/inputStringWithFormat.json"));
+const TypeResolver_1 = require("./jsonTypeResolution/TypeResolver");
+const primitiveTypes_1 = require("./primitiveTypes");
 // eslint-disable-next-line @typescript-eslint/ban-types
 function expectToThrowErrorMatchingTypeAndMessage(received, errorType, message) {
     let error = null;
@@ -44,403 +46,51 @@ describe('JsonValidationService', () => {
                 jsonValidationService.validateManifest(validComponent_json_1.default, 'invalid-version');
             }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Invalid manifest version');
         });
-    });
-    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 = jsonValidationService.validateContentSchema(contentSchema);
+        it('should return true for a valid manifest with a string format MatrixAssetUri', () => {
+            const result = jsonValidationService.validateManifest(inputStringWithFormat_json_1.default, 'v1');
             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(() => {
-                jsonValidationService.validateContentSchema(contentSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: 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(() => {
-                jsonValidationService.validateContentSchema(contentSchema);
-            }, SchemaValidationError_1.SchemaValidationError, `failed validation: 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(() => {
-                jsonValidationService.validateContentSchema(contentSchema);
-            }, SchemaValidationError_1.SchemaValidationError, 'failed validation: The required property `required` is missing at `#`');
-        });
     });
-    describe('validateComponentInput', () => {
-        describe('FormattedText input', () => {
-            it('should handle type as an array', () => {
-                const functionInputSchema = {
-                    type: 'object',
-                    properties: {
-                        'my-input': { type: ['number', 'string'] },
-                    },
-                    required: ['my-input'],
-                };
-                expect(jsonValidationService.validateComponentInput(functionInputSchema, {
-                    'my-input': 'formattedText',
-                })).toEqual(true);
-                expect(jsonValidationService.validateComponentInput(functionInputSchema, {
-                    'my-input': 123,
-                })).toEqual(true);
-            });
-            it('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(jsonValidationService.validateComponentInput(functionInputSchema, {
-                    'my-input': formattedText,
-                })).toEqual(true);
-                expect(jsonValidationService.validateComponentInput(functionInputSchema, {
-                    'my-input': 'hello',
-                })).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(jsonValidationService.validateComponentInput(functionInputSchema, inputValue)).toEqual(true);
-            });
-            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(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }, SchemaValidationError_1.SchemaValidationError, `failed validation: Expected \`123\` (number) in \`#/my-input\` to be of type \`array\``);
-            });
-            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(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }, SchemaValidationError_1.SchemaValidationError, `failed validation: Expected \`[object Object]\` (object) in \`#/my-input\` to be of type \`array\``);
-            });
-            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(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Object at `#/my-input/0` does not match any 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(jsonValidationService.validateComponentInput(schema, value)).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(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected `[object Object]` (object) in `#/deep/arr/0/formattedTextArray/2` to be of type `array`');
-            });
-            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(jsonValidationService.validateComponentInput(schema, value)).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(() => {
-                    jsonValidationService.validateComponentInput(schema, value);
-                }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected `[object Object]` (object) in `#/my-input` to be of type `array`');
-            });
-            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(jsonValidationService.validateComponentInput(schema, value)).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(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
-            });
-        });
-        describe('standard inputs', () => {
+    describe('validateRenderInput', () => {
+        describe('matrix-asset-uri input', () => {
             const functionInputSchema = {
                 type: 'object',
                 properties: {
-                    'my-input': { type: 'number' },
+                    'matrix-asset': { type: 'string', format: 'matrix-asset-uri', matrixAssetTypes: ['image'] },
                 },
-                required: ['my-input'],
+                required: ['matrix-asset'],
             };
-            it('should return true for valid input values', () => {
-                const inputValue = {
-                    'my-input': 123,
-                };
-                const result = jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                expect(result).toBe(true);
+            it('should return true for valid a string with matrix-asset-uri format', () => {
+                const validMatrixAssetUri = 'matrix-asset://canary.uat.matrix.squiz.cloud/abc123';
+                expect(jsonValidationService.validateRenderInput(functionInputSchema, {
+                    'matrix-asset': validMatrixAssetUri,
+                })).toEqual(true);
             });
-            it('should throw a SchemaValidationError for invalid input type', () => {
-                const inputValue = {
-                    'my-input': '123',
-                };
+            it('should throw error for invalid matrix-asset-uri format', () => {
+                const invalidMatrixAssetUri = 'not-valid://canary.uat.matrix.squiz.cloud//abc123';
                 expectToThrowErrorMatchingTypeAndMessage(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }, SchemaValidationError_1.SchemaValidationError, `failed validation: Expected \`123\` (string) in \`#/my-input\` to be of type \`number\``);
+                    jsonValidationService.validateRenderInput(functionInputSchema, {
+                        'matrix-asset': invalidMatrixAssetUri,
+                    });
+                }, SchemaValidationError_1.SchemaValidationError, `failed validation: value "not-valid://canary.uat.matrix.squiz.cloud//abc123" isn't a valid matrix asset uri`);
             });
-            it('should throw a SchemaValidationError for invalid input missing properties', () => {
-                const inputValue = {};
+            it('should throw error for invalid matrix-asset-uri type number', () => {
+                const invalidMatrixAssetUri = 1234;
                 expectToThrowErrorMatchingTypeAndMessage(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }, SchemaValidationError_1.SchemaValidationError, `failed validation: The required property \`my-input\` is missing at \`#\``);
+                    jsonValidationService.validateRenderInput(functionInputSchema, {
+                        'matrix-asset': invalidMatrixAssetUri,
+                    });
+                }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected `1234` (number) in `#/matrix-asset` to be of type `string`');
             });
-            it('should throw a SchemaValidationError with a truncated enum value list if there are more than 5 enum options', () => {
+            it('should throw error for invalid matrix-asset-uri which does not contain correct number of parts', () => {
+                const invalidMatrixAssetUri = 'matrix://';
                 expectToThrowErrorMatchingTypeAndMessage(() => {
-                    jsonValidationService.validateComponentInput({ type: 'object', properties: { enum: { type: 'string', enum: ['a', 'b', 'c', 'd', 'e', 'f', 'g'] } } }, { enum: 'z' });
-                }, SchemaValidationError_1.SchemaValidationError, 'failed validation: 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(() => {
-                    jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-                }).toThrowErrorMatchingInlineSnapshot();
+                    jsonValidationService.validateRenderInput(functionInputSchema, {
+                        'matrix-asset': invalidMatrixAssetUri,
+                    });
+                }, SchemaValidationError_1.SchemaValidationError, `failed validation: value "matrix://" isn't a valid matrix asset uri`);
             });
         });
-    });
-    describe('validateRenderInput', () => {
         it('should validate a property with type FormattedText as string', () => {
             const schema = {
                 type: 'object',
@@ -523,29 +173,426 @@ const defaultSchema = {
     required: ['myProperty'],
 };
 function primitiveTypeFixture(title, schema = defaultSchema) {
-    return (0, arbitraryTypeResolution_1.PrimitiveType)({
+    return (0, TypeResolver_1.PrimitiveType)({
         ...schema,
         title,
     });
 }
 function resolvableTypeFixture(title, schema = defaultSchema) {
-    return (0, arbitraryTypeResolution_1.ResolvableType)({
+    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`');
+        });
+        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\``);
+        });
+        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 `#`');
+        });
+    });
+    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');
+        });
+        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');
+        });
+        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');
+        });
+        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');
+        });
+        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');
+        });
+        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);
+        });
+    });
+    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\``);
+        });
+        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 \`#\``);
+        });
+        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]`');
+        });
+        // 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 jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-                MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            }, {
+            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);
@@ -553,14 +600,13 @@ describe('JsonSchemaService', () => {
         });
         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 jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-                MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            }, {
+            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);
@@ -570,14 +616,13 @@ describe('JsonSchemaService', () => {
         });
         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 jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-                MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            }, {
+            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);
@@ -589,13 +634,11 @@ describe('JsonSchemaService', () => {
         });
         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 jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-                MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            }, {
+            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);
@@ -605,24 +648,24 @@ describe('JsonSchemaService', () => {
         });
         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 arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableSrcNumber: resolvableTypeFixture('MyResolvableSrcNumber', {
+            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [
+                resolvableTypeFixture('MyResolvableSrcNumber', {
                     type: 'object',
                     properties: {
                         src: { type: 'number' },
                     },
                 }),
-                MyResolvableSrcString: resolvableTypeFixture('MyResolvableSrcString', {
+                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);
@@ -641,14 +684,14 @@ describe('JsonSchemaService', () => {
     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 arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-                MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            }, {
+            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);
@@ -659,20 +702,20 @@ describe('JsonSchemaService', () => {
             [{ 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 arbitraryTypeResolution_1.TypeResolver({
-                MyPrimitive: primitiveSchema,
-            }, {
-                MyResolvableSrcString: resolvableTypeFixture('MyResolvableSrcString', {
+            const jsonSchemaService = new JsonValidationService_1.JSONSchemaService(new TypeResolver_1.TypeResolver([primitiveSchema], [
+                resolvableTypeFixture('MyResolvableSrcString', {
                     type: 'object',
                     properties: { src: { type: 'string' } },
                 }),
-                MyResolvableSrcNumber: resolvableTypeFixture('MyResolvableSrcNumber', {
+                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);