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

package/src/JsonValidationService.spec.ts

@@ -4,8 +4,16 @@ import { SchemaValidationError } from './errors/SchemaValidationError';
 import validManifest from './manifest/v1/__test__/schemas/validComponent.json';
 import validManifestJson from './manifest/v1/__test__/schemas/validComponentJson.json';
 import { FormattedText } from './formatted-text/v1/formattedText';
+import inputStringWithFormat from './manifest/v1/__test__/schemas/inputStringWithFormat.json';
 import { JSONSchema } from 'json-schema-library';
-import { PrimitiveType, ResolvableType, TypeResolver } from './jsonTypeResolution/arbitraryTypeResolution';
+import {
+  AnyPrimitiveType,
+  AnyResolvableType,
+  PrimitiveType,
+  ResolvableType,
+  TypeResolver,
+} from './jsonTypeResolution/TypeResolver';
+import { FormattedTextType } from './primitiveTypes';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 function expectToThrowErrorMatchingTypeAndMessage(received: Function, errorType: Function, message: string) {
@@ -59,8 +67,182 @@ describe('JsonValidationService', () => {
         'failed validation: Invalid manifest version',
       );
     });
+
+    it('should return true for a valid manifest with a string format MatrixAssetUri', () => {
+      const result = jsonValidationService.validateManifest(inputStringWithFormat, 'v1');
+      expect(result).toBe(true);
+    });
   });
 
+  describe('validateRenderInput', () => {
+    describe('matrix-asset-uri input', () => {
+      const functionInputSchema = {
+        type: 'object',
+
+        properties: {
+          'matrix-asset': { type: 'string', format: 'matrix-asset-uri', matrixAssetTypes: ['image'] },
+        },
+
+        required: ['matrix-asset'],
+      };
+      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 error for invalid matrix-asset-uri format', () => {
+        const invalidMatrixAssetUri = 'not-valid://canary.uat.matrix.squiz.cloud//abc123';
+        expectToThrowErrorMatchingTypeAndMessage(
+          () => {
+            jsonValidationService.validateRenderInput(functionInputSchema, {
+              'matrix-asset': invalidMatrixAssetUri,
+            });
+          },
+          SchemaValidationError,
+          `failed validation: value "not-valid://canary.uat.matrix.squiz.cloud//abc123" isn't a valid matrix asset uri`,
+        );
+      });
+      it('should throw error for invalid matrix-asset-uri type number', () => {
+        const invalidMatrixAssetUri = 1234;
+        expectToThrowErrorMatchingTypeAndMessage(
+          () => {
+            jsonValidationService.validateRenderInput(functionInputSchema, {
+              'matrix-asset': invalidMatrixAssetUri,
+            });
+          },
+          SchemaValidationError,
+          'failed validation: Expected `1234` (number) in `#/matrix-asset` to be of type `string`',
+        );
+      });
+      it('should throw error for invalid matrix-asset-uri which does not contain correct number of parts', () => {
+        const invalidMatrixAssetUri = 'matrix://';
+        expectToThrowErrorMatchingTypeAndMessage(
+          () => {
+            jsonValidationService.validateRenderInput(functionInputSchema, {
+              'matrix-asset': invalidMatrixAssetUri,
+            });
+          },
+          SchemaValidationError,
+          `failed validation: value "matrix://" isn't a valid matrix asset uri`,
+        );
+      });
+    });
+
+    it('should validate a property with type FormattedText as string', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          'my-input': { type: 'FormattedText' },
+        },
+        required: ['my-input'],
+      };
+      const value = {
+        'my-input': 'hello',
+      };
+
+      expect(jsonValidationService.validateRenderInput(schema, value)).toEqual(true);
+    });
+
+    it('should error when a property with type FormattedText is provided a valid FormattedText value', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          'my-input': { type: 'FormattedText' },
+        },
+        required: ['my-input'],
+      };
+      const value = {
+        'my-input': [{ type: 'text', value: 'hello' }],
+      };
+
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validateRenderInput(schema, value);
+        },
+        SchemaValidationError,
+        'failed validation: Expected `[object Object]` (array) in `#/my-input` to be of type `string`',
+      );
+    });
+
+    it('should validate a property with type FormattedText within an if/then/else as string', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          'my-input': {
+            type: 'object',
+            properties: {
+              prop: { type: 'string' },
+            },
+            required: ['prop'],
+            if: { properties: { prop: { const: 'a' } } },
+            then: {
+              properties: {
+                text: { type: 'FormattedText' },
+              },
+              required: ['text'],
+            },
+            else: {
+              properties: {
+                text: { type: 'array', items: { type: 'FormattedText' } },
+              },
+              required: ['text'],
+            },
+          },
+        },
+        required: ['my-input'],
+      };
+      const value = {
+        'my-input': {
+          prop: 'a',
+          text: 'hello',
+        },
+      };
+
+      expect(jsonValidationService.validateRenderInput(schema, value)).toEqual(true);
+
+      const otherValue = {
+        'my-input': {
+          prop: 'b',
+          text: ['my', 'formatted', 'text'],
+        },
+      };
+      expect(jsonValidationService.validateRenderInput(schema, otherValue)).toEqual(true);
+    });
+  });
+});
+
+const defaultSchema: JSONSchema = {
+  type: 'object',
+  properties: {
+    myProperty: {
+      type: 'string',
+    },
+  },
+  required: ['myProperty'],
+};
+function primitiveTypeFixture<T extends string>(title: T, schema: JSONSchema = defaultSchema) {
+  return PrimitiveType({
+    ...schema,
+    title,
+  });
+}
+
+function resolvableTypeFixture<T extends string>(title: T, schema: JSONSchema = defaultSchema) {
+  return ResolvableType({
+    ...schema,
+    title,
+  });
+}
+
+describe('JsonSchemaService', () => {
+  let jsonSchemaService: JSONSchemaService<AnyPrimitiveType, AnyResolvableType>;
+  beforeAll(() => {
+    const typeResolver = new TypeResolver([FormattedTextType]);
+    jsonSchemaService = new JSONSchemaService(typeResolver, ComponentInputMetaSchema);
+  });
   describe('validateContentSchema', () => {
     it('should return true for a valid content schema', () => {
       const contentSchema = {
@@ -72,7 +254,7 @@ describe('JsonValidationService', () => {
 
         required: ['my-input'],
       };
-      const result = jsonValidationService.validateContentSchema(contentSchema);
+      const result = jsonSchemaService.validateInput(contentSchema);
       expect(result).toBe(true);
     });
 
@@ -94,7 +276,7 @@ describe('JsonValidationService', () => {
       };
       expectToThrowErrorMatchingTypeAndMessage(
         () => {
-          jsonValidationService.validateContentSchema(contentSchema);
+          jsonSchemaService.validateInput(contentSchema);
         },
         SchemaValidationError,
         'failed validation: The required property `required` is missing at `#/properties/my-input`',
@@ -115,7 +297,7 @@ describe('JsonValidationService', () => {
       };
       expectToThrowErrorMatchingTypeAndMessage(
         () => {
-          jsonValidationService.validateContentSchema(contentSchema);
+          jsonSchemaService.validateInput(contentSchema);
         },
         SchemaValidationError,
         `failed validation: Expected value at \`#/type\` to be \`object\`, but value given is \`array\``,
@@ -132,7 +314,7 @@ describe('JsonValidationService', () => {
       };
       expectToThrowErrorMatchingTypeAndMessage(
         () => {
-          jsonValidationService.validateContentSchema(contentSchema);
+          jsonSchemaService.validateInput(contentSchema);
         },
         SchemaValidationError,
         'failed validation: The required property `required` is missing at `#`',
@@ -140,570 +322,467 @@ describe('JsonValidationService', () => {
     });
   });
 
-  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'],
-        };
+  describe('FormattedText input', () => {
+    it('should handle type as an array', () => {
+      const functionInputSchema = {
+        type: 'object',
 
-        expect(
-          jsonValidationService.validateComponentInput(functionInputSchema, {
-            'my-input': 'formattedText',
-          }),
-        ).toEqual(true);
+        properties: {
+          'my-input': { type: ['number', 'string'] },
+        },
 
-        expect(
-          jsonValidationService.validateComponentInput(functionInputSchema, {
-            'my-input': 123,
-          }),
-        ).toEqual(true);
-      });
+        required: ['my-input'],
+      };
 
-      it('should handle type is an array of both string and FormattedText', () => {
-        const formattedText: FormattedText = [
+      expect(
+        jsonSchemaService.validateInput(
           {
-            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' },
+            'my-input': 'formattedText',
           },
+          functionInputSchema,
+        ),
+      ).toEqual(true);
 
-          required: ['my-input'],
-        };
-
-        const formattedText: FormattedText = [
+      expect(
+        jsonSchemaService.validateInput(
           {
-            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,
-          `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);
+            'my-input': 123,
           },
-          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',
+          functionInputSchema,
+        ),
+      ).toEqual(true);
+    });
 
-          properties: {
-            'my-input': { type: 'FormattedText' },
-          },
+    it.failing('should handle type is an array of both string and FormattedText', () => {
+      const formattedText: 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',
 
-          required: ['my-input'],
-        };
-        const formattedText: 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 as any }, // see here
-              { type: 'text', value: '.' },
-            ],
-          },
-        ];
+        properties: {
+          'my-input': { type: ['FormattedText', 'string'] },
+        },
 
-        const inputValue = {
-          'my-input': formattedText,
-        };
-        expectToThrowErrorMatchingTypeAndMessage(
-          () => {
-            jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-          },
-          SchemaValidationError,
-          'failed validation: Object at `#/my-input/0` does not match any schema',
-        );
-      });
+        required: ['my-input'],
+      };
 
-      it('should validate an array of formatted texts', () => {
-        const formattedText: FormattedText = [
+      expect(
+        jsonSchemaService.validateInput(
           {
-            tag: 'p',
-            type: 'tag',
-            children: [{ type: 'text', value: 'hello' }],
-          },
-        ];
-
-        const schema = {
-          type: 'object',
-          properties: {
-            arr: {
-              type: 'array',
-              items: { type: 'FormattedText' },
-            },
+            'my-input': formattedText,
           },
-        };
-        const value = {
-          arr: [formattedText],
-        };
-
-        expect(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
-      });
+          functionInputSchema,
+        ),
+      ).toEqual(true);
 
-      it('should throw an error if the FormattedText input is invalid formatted text (deeply, deeply nested)', () => {
-        const formattedText: FormattedText = [
+      expect(
+        jsonSchemaService.validateInput(
           {
-            tag: 'p',
-            type: 'tag',
-            children: [{ type: 'text', value: 'hello' }],
-          },
-        ];
-
-        const inputValue: any = {
-          '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);
+            'my-input': 'hello',
           },
-          SchemaValidationError,
-          'failed validation: Expected `[object Object]` (object) in `#/deep/arr/0/formattedTextArray/2` to be of type `array`',
-        );
-      });
+          functionInputSchema,
+        ),
+      ).toEqual(true);
+    });
 
-      it('should validate a FormattedText value when the schema is a $ref', async () => {
-        const formattedText: FormattedText = [
-          {
-            tag: 'p',
-            type: 'tag',
-            children: [{ type: 'text', value: 'hello' }],
-          },
-        ];
+    it('should return true if input is formatted text', () => {
+      const functionInputSchema = {
+        type: 'object',
 
-        const schema = {
-          type: 'object',
-          properties: {
-            'my-input': { $ref: '#/definitions/FormattedText' },
-          },
-          definitions: {
-            FormattedText: { type: 'FormattedText' },
-          },
-          required: ['my-input'],
-        };
-        const value = {
-          'my-input': formattedText,
-        };
+        properties: {
+          'my-input': { type: 'FormattedText' },
+        },
 
-        expect(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
-      });
+        required: ['my-input'],
+      };
 
-      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' },
-        };
+      const formattedText: 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,
+      };
 
-        expectToThrowErrorMatchingTypeAndMessage(
-          () => {
-            jsonValidationService.validateComponentInput(schema, value);
-          },
-          SchemaValidationError,
-          'failed validation: Expected `[object Object]` (object) in `#/my-input` to be of type `array`',
-        );
-      });
+      expect(() => jsonSchemaService.validateInput(inputValue, functionInputSchema)).not.toThrow();
+    });
 
-      it('should validate a FormattedText value when the schema is a $ref to a $ref', async () => {
-        const formattedText: FormattedText = [
-          {
-            tag: 'p',
-            type: 'tag',
-            children: [{ type: 'text', value: 'hello' }],
-          },
-        ];
+    it('should throw an error if the FormattedText input is not formatted text', () => {
+      const functionInputSchema = {
+        type: 'object',
 
-        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,
-        };
+        properties: {
+          'my-input': { type: 'FormattedText' },
+        },
 
-        expect(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
-      });
+        required: ['my-input'],
+      };
+      const inputValue = {
+        'my-input': 123,
+      };
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonSchemaService.validateInput(inputValue, functionInputSchema);
+        },
+        SchemaValidationError,
+        'failed validation: Value `123` in `#/my-input` does not match any given oneof schema',
+      );
+    });
 
-      it('should validate a FormattedText value when the schema is in an if/then/else', async () => {
-        const formattedText: FormattedText = [
-          {
-            tag: 'p',
-            type: 'tag',
-            children: [{ type: 'text', value: 'hello' }],
-          },
-        ];
+    it('should throw an error if the FormattedText input is invalid formatted text', () => {
+      const functionInputSchema = {
+        type: 'object',
 
-        const schema = {
-          type: 'object',
-          properties: {
-            'my-input': {
-              if: { type: 'string' },
-              then: { type: 'string' },
-              else: { type: 'FormattedText' },
-            },
-          },
-          required: ['my-input'],
-        };
-        const value = {
-          'my-input': formattedText,
-        };
+        properties: {
+          'my-input': { type: 'FormattedText' },
+        },
 
-        expect(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
-      });
+        required: ['my-input'],
+      };
+      const inputValue = {
+        'my-input': {
+          something: 'aa',
+        },
+      };
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonSchemaService.validateInput(inputValue, functionInputSchema);
+        },
+        SchemaValidationError,
+        'failed validation: Value `{"something":"aa"}` in `#/my-input` does not match any given oneof schema',
+      );
     });
 
-    describe('standard inputs', () => {
+    it('should throw an error if the FormattedText input is invalid formatted text (deeply nested)', () => {
       const functionInputSchema = {
         type: 'object',
 
         properties: {
-          'my-input': { type: 'number' },
+          'my-input': { type: 'FormattedText' },
         },
 
         required: ['my-input'],
       };
+      const formattedText: 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 as any }, // see here
+            { type: 'text', value: '.' },
+          ],
+        },
+      ];
 
-      it('should return true for valid input values', () => {
-        const inputValue = {
-          'my-input': 123,
-        };
-        const result = jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-        expect(result).toBe(true);
-      });
+      const inputValue = {
+        'my-input': formattedText,
+      };
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonSchemaService.validateInput(inputValue, functionInputSchema);
+        },
+        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 throw a SchemaValidationError for invalid input type', () => {
-        const inputValue = {
-          'my-input': '123',
-        };
-        expectToThrowErrorMatchingTypeAndMessage(
-          () => {
-            jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-          },
-          SchemaValidationError,
-          `failed validation: Expected \`123\` (string) in \`#/my-input\` to be of type \`number\``,
-        );
-      });
+    it('should validate an array of formatted texts', () => {
+      const formattedText: FormattedText = [
+        {
+          tag: 'p',
+          type: 'tag',
+          children: [{ type: 'text', value: 'hello' }],
+        },
+      ];
 
-      it('should throw a SchemaValidationError for invalid input missing properties', () => {
-        const inputValue = {};
-        expectToThrowErrorMatchingTypeAndMessage(
-          () => {
-            jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
+      const schema = {
+        type: 'object',
+        properties: {
+          arr: {
+            type: 'array',
+            items: { type: 'FormattedText' },
           },
-          SchemaValidationError,
-          `failed validation: The required property \`my-input\` is missing at \`#\``,
-        );
-      });
+        },
+      };
+      const value = {
+        arr: [formattedText],
+      };
 
-      it('should throw a SchemaValidationError with a truncated enum value list if there are more than 5 enum options', () => {
-        expectToThrowErrorMatchingTypeAndMessage(
-          () => {
-            jsonValidationService.validateComponentInput(
-              { type: 'object', properties: { enum: { type: 'string', enum: ['a', 'b', 'c', 'd', 'e', 'f', 'g'] } } },
-              { enum: 'z' },
-            );
+      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: FormattedText = [
+        {
+          tag: 'p',
+          type: 'tag',
+          children: [{ type: 'text', value: 'hello' }],
+        },
+      ];
+
+      const inputValue: any = {
+        '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'],
           },
-          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();
-      });
+        required: ['my-input', 'deep'],
+      };
+
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonSchemaService.validateInput(inputValue, functionInputSchema);
+        },
+        SchemaValidationError,
+        'failed validation: Value `{"bad":"data"}` in `#/deep/arr/0/formattedTextArray/2` does not match any given oneof schema',
+      );
     });
-  });
 
-  describe('validateRenderInput', () => {
-    it('should validate a property with type FormattedText as string', () => {
+    it('should validate a FormattedText value when the schema is a $ref', async () => {
+      const formattedText: FormattedText = [
+        {
+          tag: 'p',
+          type: 'tag',
+          children: [{ type: 'text', value: 'hello' }],
+        },
+      ];
+
       const schema = {
         type: 'object',
         properties: {
-          'my-input': { type: 'FormattedText' },
+          'my-input': { $ref: '#/definitions/FormattedText' },
+        },
+        definitions: {
+          FormattedText: { type: 'FormattedText' },
         },
         required: ['my-input'],
       };
       const value = {
-        'my-input': 'hello',
+        'my-input': formattedText,
       };
 
-      expect(jsonValidationService.validateRenderInput(schema, value)).toEqual(true);
+      expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
     });
 
-    it('should error when a property with type FormattedText is provided a valid FormattedText value', () => {
+    it('should error when a FormattedText value is invalid when the schema is a $ref', async () => {
       const schema = {
         type: 'object',
         properties: {
-          'my-input': { type: 'FormattedText' },
+          'my-input': { $ref: '#/definitions/FormattedText' },
+        },
+        definitions: {
+          FormattedText: { type: 'FormattedText' },
         },
         required: ['my-input'],
       };
       const value = {
-        'my-input': [{ type: 'text', value: 'hello' }],
+        'my-input': { bad: 'data' },
       };
 
       expectToThrowErrorMatchingTypeAndMessage(
         () => {
-          jsonValidationService.validateRenderInput(schema, value);
+          jsonSchemaService.validateInput(value, schema);
         },
         SchemaValidationError,
-        'failed validation: Expected `[object Object]` (array) in `#/my-input` to be of type `string`',
+        'failed validation: Value `{"bad":"data"}` in `#/my-input` does not match any given oneof schema',
       );
     });
 
-    it('should validate a property with type FormattedText within an if/then/else as string', () => {
+    it('should validate a FormattedText value when the schema is a $ref to a $ref', async () => {
+      const formattedText: FormattedText = [
+        {
+          tag: 'p',
+          type: 'tag',
+          children: [{ type: 'text', value: 'hello' }],
+        },
+      ];
+
       const schema = {
         type: 'object',
         properties: {
-          'my-input': {
-            type: 'object',
-            properties: {
-              prop: { type: 'string' },
-            },
-            required: ['prop'],
-            if: { properties: { prop: { const: 'a' } } },
-            then: {
-              properties: {
-                text: { type: 'FormattedText' },
-              },
-              required: ['text'],
-            },
-            else: {
-              properties: {
-                text: { type: 'array', items: { type: 'FormattedText' } },
-              },
-              required: ['text'],
-            },
-          },
+          'my-input': { $ref: '#/definitions/FormattedText' },
+        },
+        definitions: {
+          FormattedText: { $ref: '#/definitions/FormattedText2' },
+          FormattedText2: { type: 'FormattedText' },
         },
         required: ['my-input'],
       };
       const value = {
-        'my-input': {
-          prop: 'a',
-          text: 'hello',
-        },
+        'my-input': formattedText,
       };
 
-      expect(jsonValidationService.validateRenderInput(schema, value)).toEqual(true);
+      expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
+    });
 
-      const otherValue = {
-        'my-input': {
-          prop: 'b',
-          text: ['my', 'formatted', 'text'],
+    it('should validate a FormattedText value when the schema is in an if/then/else', async () => {
+      const formattedText: 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'],
       };
-      expect(jsonValidationService.validateRenderInput(schema, otherValue)).toEqual(true);
+      const value = {
+        'my-input': formattedText,
+      };
+
+      expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
     });
   });
-});
 
-const defaultSchema: JSONSchema = {
-  type: 'object',
-  properties: {
-    myProperty: {
-      type: 'string',
-    },
-  },
-  required: ['myProperty'],
-};
-function primitiveTypeFixture<T extends string>(title: T, schema: JSONSchema = defaultSchema) {
-  return PrimitiveType({
-    ...schema,
-    title,
-  });
-}
+  describe('standard inputs', () => {
+    const functionInputSchema = {
+      type: 'object',
 
-function resolvableTypeFixture<T extends string>(title: T, schema: JSONSchema = defaultSchema) {
-  return ResolvableType({
-    ...schema,
-    title,
+      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,
+        `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,
+        `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,
+        '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('JsonSchemaService', () => {
   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 JSONSchemaService(
-          new TypeResolver(
-            {
-              MyPrimitive: primitiveSchema,
-            },
-            {
-              MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-              MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            },
-            {
-              MyPrimitive: {
-                MyResolvableNumber: (value: number) => value.toString(),
-                MyResolvableArray: (value: any[]) => value.join(''),
-              },
+          new TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
+            MyPrimitive: {
+              // @ts-expect-error - fixture is unknown but we know the actual shape
+              MyResolvableNumber: (value: number) => value.toString(),
+              // @ts-expect-error - fixture is unknown but we know the actual shape
+              MyResolvableArray: (value: any[]) => value.join(''),
             },
-          ),
+          }),
           ComponentInputMetaSchema,
         );
 
@@ -718,22 +797,17 @@ 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 MyResolvableNumber = resolvableTypeFixture('MyResolvableNumber', { type: 'number' });
+      const MyResolvableArray = resolvableTypeFixture('MyResolvableArray', { type: 'array' });
       const jsonSchemaService = new JSONSchemaService(
-        new TypeResolver(
-          {
-            MyPrimitive: primitiveSchema,
-          },
-          {
-            MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-            MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-          },
-          {
-            MyPrimitive: {
-              MyResolvableNumber: (value: number) => value.toString(),
-              MyResolvableArray: (value: any[]) => value.join(''),
-            },
-          },
-        ),
+        new TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
+          MyPrimitive: {
+            // @ts-expect-error - fixture is unknown but we know the actual shape
+            MyResolvableNumber: (value: number) => value.toString(),
+            // @ts-expect-error - fixture is unknown but we know the actual shape
+            MyResolvableArray: (value: any[]) => value.join(''),
+          },
+        }),
         ComponentInputMetaSchema,
       );
 
@@ -749,22 +823,17 @@ describe('JsonSchemaService', () => {
       '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 JSONSchemaService(
-          new TypeResolver(
-            {
-              MyPrimitive: primitiveSchema,
-            },
-            {
-              MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-              MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            },
-            {
-              MyPrimitive: {
-                MyResolvableNumber: (value: number) => value.toString(),
-                MyResolvableArray: (value: any[]) => value.join(''),
-              },
+          new TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
+            MyPrimitive: {
+              // @ts-expect-error - fixture is unknown but we know the actual shape
+              MyResolvableNumber: (value: number) => value.toString(),
+              // @ts-expect-error - fixture is unknown but we know the actual shape
+              MyResolvableArray: (value: any[]) => value.join(''),
             },
-          ),
+          }),
           ComponentInputMetaSchema,
         );
 
@@ -783,21 +852,15 @@ 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 MyResolvableNumber = resolvableTypeFixture('MyResolvableNumber', { type: 'number' });
+      const MyResolvableArray = resolvableTypeFixture('MyResolvableArray', { type: 'array' });
       const jsonSchemaService = new JSONSchemaService(
-        new TypeResolver(
-          {
-            MyPrimitive: primitiveSchema,
-          },
-          {
-            MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-            MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-          },
-          {
-            MyPrimitive: {
-              MyResolvableNumber: (value: number) => value.toString(),
-            },
+        new TypeResolver([primitiveSchema], [MyResolvableNumber, MyResolvableArray], {
+          MyPrimitive: {
+            // @ts-expect-error - fixture is unknown but we know the actual shape
+            MyResolvableNumber: (value: number) => value.toString(),
           },
-        ),
+        }),
         ComponentInputMetaSchema,
       );
 
@@ -813,26 +876,26 @@ describe('JsonSchemaService', () => {
       const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
       const jsonSchemaService = new JSONSchemaService(
         new TypeResolver(
-          {
-            MyPrimitive: primitiveSchema,
-          },
-          {
-            MyResolvableSrcNumber: resolvableTypeFixture('MyResolvableSrcNumber', {
+          [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: { src: number }) => value.src.toString(),
+              // @ts-expect-error - fixture is unknown but we know the actual shape
               MyResolvableSrcString: (value: { src: string }) => value.src,
             },
           },
@@ -870,16 +933,16 @@ describe('JsonSchemaService', () => {
         const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
         const jsonSchemaService = new JSONSchemaService(
           new TypeResolver(
-            {
-              MyPrimitive: primitiveSchema,
-            },
-            {
-              MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
-              MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
-            },
+            [primitiveSchema],
+            [
+              resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
+              resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
+            ],
             {
               MyPrimitive: {
+                // @ts-expect-error - fixture is unknown but we know the actual shape
                 MyResolvableNumber: (value: number) => value.toString(),
+                // @ts-expect-error - fixture is unknown but we know the actual shape
                 MyResolvableArray: (value: any[]) => value.join(''),
               },
             },
@@ -903,22 +966,22 @@ describe('JsonSchemaService', () => {
       const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
       const jsonSchemaService = new JSONSchemaService(
         new TypeResolver(
-          {
-            MyPrimitive: primitiveSchema,
-          },
-          {
-            MyResolvableSrcString: resolvableTypeFixture('MyResolvableSrcString', {
+          [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: { src: number }) => value.src.toString(),
+              // @ts-expect-error - fixture is unknown but we know the actual shape
               MyResolvableSrcString: (value: { src: string }) => value.src,
             },
           },