@squiz/dx-json-schema-lib 1.2.13-alpha.1 → 1.2.13-alpha.3

package/src/JsonValidationService.spec.ts

@@ -2,14 +2,33 @@ import { JsonValidationService } from './JsonValidationService';
 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';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function expectToThrowErrorMatchingTypeAndMessage(received: Function, errorType: Function, message: string) {
+  let error: null | Error = null;
+
+  try {
+    received();
+  } catch (e: any) {
+    error = e;
+  }
+
+  expect(error).toBeDefined();
+  expect(error?.message).toEqual(message);
+  expect(error).toBeInstanceOf(errorType);
+}
 
 describe('JsonValidationService', () => {
-  let jsonValidationService: JsonValidationService;
-  beforeEach(() => {
-    jsonValidationService = new JsonValidationService();
-  });
+  const jsonValidationService: JsonValidationService = new JsonValidationService();
 
   describe('validateManifest', () => {
+    it('should return true for a valid JSON endpoint manifest', () => {
+      const result = jsonValidationService.validateManifest(validManifestJson, 'v1');
+      expect(result).toBe(true);
+    });
+
     it('should return true for a valid manifest', () => {
       const result = jsonValidationService.validateManifest(validManifest, 'v1');
       expect(result).toBe(true);
@@ -20,18 +39,23 @@ describe('JsonValidationService', () => {
 
       delete (invalidManifest as any).name;
 
-      expect(() => {
-        jsonValidationService.validateManifest(invalidManifest, 'v1');
-      }).toThrow(SchemaValidationError);
-      expect(() => {
-        jsonValidationService.validateManifest(invalidManifest, 'v1');
-      }).toMatchInlineSnapshot(`[Function]`);
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validateManifest(invalidManifest, 'v1');
+        },
+        SchemaValidationError,
+        `failed validation: The required property \`name\` is missing at \`#\``,
+      );
     });
 
     it('should throw an error for an invalid manifest version', () => {
-      expect(() => {
-        jsonValidationService.validateManifest(validManifest, 'invalid-version' as any);
-      }).toThrow(Error);
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validateManifest(validManifest, 'invalid-version' as any);
+        },
+        SchemaValidationError,
+        'failed validation: Invalid manifest version',
+      );
     });
   });
 
@@ -50,8 +74,7 @@ describe('JsonValidationService', () => {
       expect(result).toBe(true);
     });
 
-    // TODO DEVX-658
-    it.skip('should return false for an invalid content schema, where the required property is missed from a child object', () => {
+    it('should return false for an invalid content schema, where the required property is missed from a child object', () => {
       const contentSchema = {
         type: 'object',
 
@@ -67,9 +90,13 @@ describe('JsonValidationService', () => {
 
         required: ['my-input'],
       };
-      expect(() => {
-        jsonValidationService.validateContentSchema(contentSchema);
-      }).toThrow(SchemaValidationError);
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validateContentSchema(contentSchema);
+        },
+        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', () => {
@@ -84,13 +111,16 @@ describe('JsonValidationService', () => {
           required: ['my-input'],
         },
       };
-      expect(() => {
-        jsonValidationService.validateContentSchema(contentSchema);
-      }).toThrow(SchemaValidationError);
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validateContentSchema(contentSchema);
+        },
+        SchemaValidationError,
+        `failed validation: Expected value at \`#/type\` to be \`object\`, but value given is \`array\``,
+      );
     });
 
-    // TODO DEVX-658
-    it.skip('should throw a SchemaValidationError for an invalid content schema missing the required property', () => {
+    it('should throw a SchemaValidationError for an invalid content schema missing the required property', () => {
       const contentSchema = {
         type: 'object',
 
@@ -98,65 +128,344 @@ describe('JsonValidationService', () => {
           'my-input': { type: 'number' },
         },
       };
-      expect(() => {
-        jsonValidationService.validateContentSchema(contentSchema);
-      }).toThrow(SchemaValidationError);
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonValidationService.validateContentSchema(contentSchema);
+        },
+        SchemaValidationError,
+        'failed validation: The required property `required` is missing at `#`',
+      );
     });
   });
 
   describe('validateComponentInput', () => {
-    const functionInputSchema = {
-      type: 'object',
+    describe('FormattedText input', () => {
+      it('should handle type as an array', () => {
+        const functionInputSchema = {
+          type: 'object',
 
-      properties: {
-        'my-input': { type: 'number' },
-      },
+          properties: {
+            'my-input': { type: ['number', 'string'] },
+          },
 
-      required: ['my-input'],
-    };
+          required: ['my-input'],
+        };
 
-    it('should return true for valid input values', () => {
-      const inputValue = {
-        'my-input': 123,
-      };
-      const result = jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      expect(result).toBe(true);
-    });
+        expect(
+          jsonValidationService.validateComponentInput(functionInputSchema, {
+            'my-input': 'formattedText',
+          }),
+        ).toEqual(true);
 
-    it('should throw a SchemaValidationError for invalid input type', () => {
-      const inputValue = {
-        'my-input': '123',
-      };
-      expect(() => {
-        jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      }).toThrow(SchemaValidationError);
-      expect(() => {
-        jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      }).toMatchInlineSnapshot(`[Function]`);
-    });
+        expect(
+          jsonValidationService.validateComponentInput(functionInputSchema, {
+            'my-input': 123,
+          }),
+        ).toEqual(true);
+      });
+
+      it('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',
+
+          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: 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,
+          `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,
+          `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: 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: '.' },
+            ],
+          },
+        ];
+
+        const inputValue = {
+          'my-input': formattedText,
+        };
+        expectToThrowErrorMatchingTypeAndMessage(
+          () => {
+            jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
+          },
+          SchemaValidationError,
+          'failed validation: Object at `#/my-input/0` does not match any schema',
+        );
+      });
+
+      it('should validate an array of formatted texts', () => {
+        const formattedText: 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: 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' }],
+              },
+            ],
+          },
+        };
 
-    it('should throw a SchemaValidationError for invalid input missing properties', () => {
-      const inputValue = {};
-      expect(() => {
-        jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      }).toThrow(SchemaValidationError);
-      expect(() => {
-        jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      }).toMatchInlineSnapshot(`[Function]`);
+        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,
+          'failed validation: Expected `[object Object]` (object) in `#/deep/arr/0/formattedTextArray/2` to be of type `array`',
+        );
+      });
     });
 
-    // TODO DEVX-658
-    it.skip('should throw a SchemaValidationError for invalid input additional properties', () => {
-      const inputValue = {
-        'my-input': 123,
-        'my-input-2': 123,
+    describe('standard inputs', () => {
+      const functionInputSchema = {
+        type: 'object',
+
+        properties: {
+          'my-input': { type: 'number' },
+        },
+
+        required: ['my-input'],
       };
-      expect(() => {
-        jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      }).toThrow(SchemaValidationError);
-      expect(() => {
-        jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
-      }).toMatchInlineSnapshot();
+
+      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 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 throw a SchemaValidationError for invalid input missing properties', () => {
+        const inputValue = {};
+        expectToThrowErrorMatchingTypeAndMessage(
+          () => {
+            jsonValidationService.validateComponentInput(functionInputSchema, inputValue);
+          },
+          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(
+          () => {
+            jsonValidationService.validateComponentInput(
+              { type: 'object', properties: { enum: { type: 'string', enum: ['a', 'b', 'c', 'd', 'e', 'f', 'g'] } } },
+              { enum: 'z' },
+            );
+          },
+          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();
+      });
     });
   });
 });

package/src/JsonValidationService.ts

@@ -1,54 +1,132 @@
-import Ajv, { AnySchemaObject, SchemaObject } from 'ajv';
-import addFormats from 'ajv-formats';
-import betterAjvErrors from 'better-ajv-errors';
-
 import DxComponentInputSchema from './manifest/v1/DxComponentInputSchema.json';
 import DxComponentIcons from './manifest/v1/DxComponentIcons.json';
 import DxContentMetaSchema from './manifest/v1/DxContentMetaSchema.json';
+import Draft07Schema from './manifest/v1/Draft-07.json';
+
+import FormattedText from './formatted-text/v1/formattedText.json';
+
 import v1 from './manifest/v1/v1.json';
 import { SchemaValidationError } from './errors/SchemaValidationError';
+import { Draft07, JSONError, JSONSchema, Draft, DraftConfig } from 'json-schema-library';
+
+import { draft07Config } from 'json-schema-library';
+import { MANIFEST_MODELS } from '.';
+
+const defaultConfig: DraftConfig = {
+  ...draft07Config,
+  errors: {
+    ...draft07Config.errors,
+
+    enumError(data) {
+      let values = '[]';
+
+      if (data.values && Array.isArray(data.values)) {
+        if (data.values.length < 5) {
+          values = `[${data.values.join(', ')}]`;
+        } else {
+          const firstFiveValues = data.values.slice(0, 5);
+          values = `[${firstFiveValues.join(', ')}, ... ${data.values.length - 5} more]`;
+        }
+      }
+
+      return {
+        type: 'error',
+        name: 'EnumError',
+        code: 'enum-error',
+        message: `Expected given value \`${data.value}\` in ${data.pointer}\` to be one of \`${values}\``,
+        data,
+      };
+    },
+
+    anyOfError(data) {
+      let value = `Value \`${data.value}\` at`;
+
+      if (typeof data.value == 'object') {
+        value = 'Object at';
+      }
+
+      if (Array.isArray(data.value)) {
+        value = 'Array at';
+      }
+
+      return {
+        type: 'error',
+        name: 'AnyOfError',
+        code: 'any-of-error',
+        message: `${value} \`${data.pointer}\` does not match any schema`,
+        data,
+      };
+    },
+  },
+};
+
+const FTSchema = new Draft07(FormattedText);
+
+const ComponentInputSchema = new Draft(
+  {
+    ...defaultConfig,
+
+    resolveRef(schema, rootSchema) {
+      const resolvedSchema = draft07Config.resolveRef(schema, rootSchema) as MANIFEST_MODELS.v1.CoreSchemaMetaSchema;
+      if (!resolvedSchema) {
+        return resolvedSchema;
+      }
+      if (resolvedSchema.type === 'FormattedText') {
+        return FTSchema.rootSchema;
+      } else if (Array.isArray(resolvedSchema.type) && resolvedSchema.type.includes('FormattedText')) {
+        return {
+          ...schema,
+          ...FTSchema.rootSchema,
+          type: resolvedSchema.type.filter((t) => t !== 'FormattedText').concat(FormattedText.type as 'array'),
+        };
+      } else {
+        return resolvedSchema;
+      }
+    },
+  },
+  DxComponentInputSchema,
+);
+ComponentInputSchema.addRemoteSchema('DxComponentInputSchema.json/DxContentMetaSchema.json', DxContentMetaSchema);
+
+const v1Schema = new Draft07(v1, defaultConfig);
+
+v1Schema.addRemoteSchema('DxComponentInputSchema.json/DxContentMetaSchema.json', DxContentMetaSchema);
+v1Schema.addRemoteSchema('/DxComponentInputSchema.json', ComponentInputSchema.getSchema());
+v1Schema.addRemoteSchema('/DxComponentIcons.json', DxComponentIcons);
+v1Schema.addRemoteSchema('http://json-schema.org/draft-07/schema', Draft07Schema);
+v1Schema.addRemoteSchema('http://json-schema.org/draft-07/schema#', Draft07Schema);
+
+const ContentSchemaSchema = new Draft07(DxComponentInputSchema, defaultConfig);
+ContentSchemaSchema.addRemoteSchema('DxComponentInputSchema.json/DxContentMetaSchema.json', DxContentMetaSchema);
 
 export class JsonValidationService {
-  ajv: Ajv;
-  constructor() {
-    this.ajv = new Ajv({
-      strict: true,
-      schemas: { DxContentMetaSchema, v1, DxComponentIcons, DxComponentInputSchema },
-      allowUnionTypes: true,
-      allErrors: true,
-      formats: {
-        'multi-line': true,
-      },
-    });
-
-    addFormats(this.ajv);
-  }
   validateManifest(manifest: unknown, version: 'v1') {
     switch (version) {
-      case 'v1':
-        return this.doValidate(v1, manifest);
+      case 'v1': {
+        const validationResult = v1Schema.validate(manifest);
+        return this.processValidationResult(validationResult);
+      }
 
       default:
-        throw new Error('Invalid manifest version');
+        throw new SchemaValidationError('Invalid manifest version');
     }
   }
-
-  validateContentSchema(contentSchema: AnySchemaObject) {
-    // This schema matches the input definition in the manifest
-    return this.doValidate(DxComponentInputSchema, contentSchema);
+  validateContentSchema(contentSchema: JSONSchema) {
+    return this.processValidationResult(ContentSchemaSchema.validate(contentSchema));
   }
 
-  validateComponentInput(functionInputSchema: SchemaObject, inputValue: unknown) {
-    return this.doValidate(functionInputSchema, inputValue);
+  validateComponentInput(functionInputSchema: JSONSchema, inputValue: unknown) {
+    const inputSchema = ComponentInputSchema.compileSchema(functionInputSchema);
+    const errors = ComponentInputSchema.validate(inputValue, inputSchema);
+
+    return this.processValidationResult(errors);
   }
 
-  private doValidate(schema: string | SchemaObject, value: unknown): true {
-    const result = this.ajv.validate(schema, value);
-    if (!result) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const betterErrors = betterAjvErrors(schema, value, this.ajv.errors!, { format: 'js' });
-      throw new SchemaValidationError(betterErrors);
+  private processValidationResult(errors: JSONError[]): true {
+    if (errors.length > 0) {
+      throw new SchemaValidationError(errors.map((a) => a.message).join(',\n'));
     }
-    return result;
+
+    return true;
   }
 }