@squiz/dx-json-schema-lib 1.33.1-alpha.4 → 1.33.1-alpha.5

package/src/JsonValidationService.spec.ts

@@ -13,7 +13,7 @@ import {
   ResolvableType,
   TypeResolver,
 } from './jsonTypeResolution/TypeResolver';
-import { FormattedTextType } from './primitiveTypes';
+import { FormattedTextType, SquizImageType } from './primitiveTypes';
 
 function expectToThrowErrorMatchingTypeAndMessage(
   // eslint-disable-next-line @typescript-eslint/ban-types
@@ -145,7 +145,7 @@ describe('JsonValidationService', () => {
         ).toEqual(true);
       });
       it('should throw error for invalid matrix-asset-uri format', () => {
-        const invalidMatrixAssetUri = 'not-valid://canary.uat.matrix.squiz.cloud//abc123';
+        const invalidMatrixAssetUri = 'not-valid://canary uat matrix.squiz.cloud//abc123';
         expectToThrowErrorMatchingTypeAndMessage(
           () => {
             jsonValidationService.validateRenderInput(functionInputSchema, {
@@ -153,8 +153,21 @@ describe('JsonValidationService', () => {
             });
           },
           SchemaValidationError,
-          `failed validation: value "not-valid://canary.uat.matrix.squiz.cloud//abc123" isn't a valid matrix asset uri`,
-          undefined,
+          `failed validation: matrix asset uri "not-valid://canary uat matrix.squiz.cloud//abc123" isn't a valid matrix asset uri`,
+          {
+            assetId: {
+              data: { expected: /^\d+(?::.+)?$/, received: '/abc123' },
+              message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
+            },
+            identifier: {
+              data: { expected: /^[a-zA-Z0-9.-]+$/, received: 'canary uat matrix.squiz.cloud' },
+              message: 'Matrix Identifier has invalid format, must match /^[a-zA-Z0-9.-]+$/',
+            },
+            scheme: {
+              data: { expected: 'matrix-asset', received: 'not-valid' },
+              message: 'Uri scheme is invalid, must match "matrix-asset"',
+            },
+          },
         );
       });
       it('should throw error for invalid matrix-asset-uri type number', () => {
@@ -186,7 +199,21 @@ describe('JsonValidationService', () => {
             });
           },
           SchemaValidationError,
-          `failed validation: value "matrix://" isn't a valid matrix asset uri`,
+          `failed validation: matrix asset uri "matrix://" isn't a valid matrix asset uri`,
+          {
+            assetId: {
+              data: { expected: /^\d+(?::.+)?$/, received: '' },
+              message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
+            },
+            identifier: {
+              data: { expected: /^[a-zA-Z0-9.-]+$/, received: '' },
+              message: 'Matrix Identifier has invalid format, must match /^[a-zA-Z0-9.-]+$/',
+            },
+            scheme: {
+              data: { expected: 'matrix-asset', received: 'matrix' },
+              message: 'Uri scheme is invalid, must match "matrix-asset"',
+            },
+          },
         );
       });
     });
@@ -223,11 +250,12 @@ describe('JsonValidationService', () => {
           jsonValidationService.validateRenderInput(schema, value);
         },
         SchemaValidationError,
-        'failed validation: Expected `[object Object]` (array) in `#/my-input` to be of type `string`',
+        'failed validation: Expected `Array [{"type":"text","value":"hello"}]` (array) in `#/my-input` to be of type `string`',
         {
           '#/my-input': [
             {
-              message: 'Expected `[object Object]` (array) in `#/my-input` to be of type `string`',
+              message:
+                'Expected `Array [{"type":"text","value":"hello"}]` (array) in `#/my-input` to be of type `string`',
               data: {
                 received: 'array',
                 expected: 'string',
@@ -353,6 +381,14 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: The required property `required` is missing at `#/properties/my-input`',
+        {
+          '#/properties/my-input': [
+            {
+              data: { key: 'required', pointer: '#/properties/my-input' },
+              message: 'The required property `required` is missing at `#/properties/my-input`',
+            },
+          ],
+        },
       );
     });
 
@@ -374,6 +410,14 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         `failed validation: Expected value at \`#/type\` to be \`object\`, but value given is \`array\``,
+        {
+          '#/type': [
+            {
+              data: { expected: 'object', pointer: '#/type', value: 'array' },
+              message: 'Expected value at `#/type` to be `object`, but value given is `array`',
+            },
+          ],
+        },
       );
     });
 
@@ -391,6 +435,83 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: The required property `required` is missing at `#`',
+        {
+          '#': [
+            { data: { key: 'required', pointer: '#' }, message: 'The required property `required` is missing at `#`' },
+          ],
+        },
+      );
+    });
+  });
+
+  describe('SquizImage input', () => {
+    it('should validate a squizImage input', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          image: {
+            type: 'SquizImage',
+          },
+        },
+      };
+
+      const value: SquizImageType['__shape__'] = {
+        name: 'My Image',
+        alt: 'My Image that did not load',
+        caption: 'This above is a loaded image',
+        imageVariations: {
+          original: {
+            url: 'https://picsum.photos/200/300',
+            width: 100,
+            height: 100,
+            byteSize: 1000,
+            mimeType: 'image/jpeg',
+            aspectRatio: '1:1',
+            sha1Hash: '1234567890abcdef1234567890abcdef12345678',
+          },
+        },
+      };
+      expect(jsonSchemaService.validateInput(value, schema)).toEqual(true);
+    });
+
+    it('should error if SquizImage type is missing required properties', async () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          myProp: {
+            type: 'SquizImage',
+          },
+        },
+      };
+
+      const value: { myProp: SquizImageType['__shape__'] } = {
+        // @ts-expect-error - missing required properties
+        myProp: {
+          alt: 'alt',
+          caption: 'caption',
+          name: 'name',
+        },
+      };
+      expectToThrowErrorMatchingTypeAndMessage(
+        () => {
+          jsonSchemaService.validateInput(value, schema);
+        },
+        SchemaValidationError,
+        'failed validation: Expected `Object {"alt":"alt","caption":"caption","name":"name"}` (object) in `#/myProp` to be of type `SquizImage`',
+        {
+          '#/myProp': [
+            {
+              data: {
+                expected: 'SquizImage',
+                pointer: '#/myProp',
+                received: 'object',
+                value: { alt: 'alt', caption: 'caption', name: 'name' },
+              },
+              message:
+                'Expected `Object {"alt":"alt","caption":"caption","name":"name"}` (object) in `#/myProp` to be of type `SquizImage`',
+            },
+          ],
+        },
       );
     });
   });
@@ -517,6 +638,27 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: Value `123` in `#/my-input` does not match any given oneof schema',
+        {
+          '#/my-input': [
+            {
+              data: {
+                errors: [
+                  {
+                    code: 'type-error',
+                    data: { expected: 'array', pointer: '#/my-input', received: 'number', value: 123 },
+                    message: 'Expected `123` (number) in `#/my-input` to be of type `array`',
+                    name: 'TypeError',
+                    type: 'error',
+                  },
+                ],
+                oneOf: [{ $ref: 'FormattedText.json' }],
+                pointer: '#/my-input',
+                value: '123',
+              },
+              message: 'Value `123` in `#/my-input` does not match any given oneof schema',
+            },
+          ],
+        },
       );
     });
 
@@ -541,6 +683,27 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: Value `{"something":"aa"}` in `#/my-input` does not match any given oneof schema',
+        {
+          '#/my-input': [
+            {
+              data: {
+                errors: [
+                  {
+                    code: 'type-error',
+                    data: { expected: 'array', pointer: '#/my-input', received: 'object', value: { something: 'aa' } },
+                    message: 'Expected `Object {"something":"aa"}` (object) in `#/my-input` to be of type `array`',
+                    name: 'TypeError',
+                    type: 'error',
+                  },
+                ],
+                oneOf: [{ $ref: 'FormattedText.json' }],
+                pointer: '#/my-input',
+                value: '{"something":"aa"}',
+              },
+              message: 'Value `{"something":"aa"}` in `#/my-input` does not match any given oneof schema',
+            },
+          ],
+        },
       );
     });
 
@@ -577,6 +740,46 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: Value `[{"tag":"p","type":"tag","children":[{"type":"text","value":"This is some "},{"type":"text","value":"Link to asset 12345"},{"type":"text","value":" with an image "},{"type":"text","value":123},{"type":"text","value":"."}]}]` in `#/my-input` does not match any given oneof schema',
+        {
+          '#/my-input': [
+            {
+              data: {
+                errors: [
+                  {
+                    code: 'any-of-error',
+                    data: {
+                      anyOf: [
+                        { $ref: '#/definitions/HigherOrderFormattedNodes' },
+                        { $ref: '#/definitions/BaseFormattedNodes' },
+                      ],
+                      pointer: '#/my-input/0',
+                      value: {
+                        children: [
+                          { type: 'text', value: 'This is some ' },
+                          { type: 'text', value: 'Link to asset 12345' },
+                          { type: 'text', value: ' with an image ' },
+                          { type: 'text', value: 123 },
+                          { type: 'text', value: '.' },
+                        ],
+                        tag: 'p',
+                        type: 'tag',
+                      },
+                    },
+                    message: 'Object at `#/my-input/0` does not match any schema',
+                    name: 'AnyOfError',
+                    type: 'error',
+                  },
+                ],
+                oneOf: [{ $ref: 'FormattedText.json' }],
+                pointer: '#/my-input',
+                value:
+                  '[{"tag":"p","type":"tag","children":[{"type":"text","value":"This is some "},{"type":"text","value":"Link to asset 12345"},{"type":"text","value":" with an image "},{"type":"text","value":123},{"type":"text","value":"."}]}]',
+              },
+              message:
+                'Value `[{"tag":"p","type":"tag","children":[{"type":"text","value":"This is some "},{"type":"text","value":"Link to asset 12345"},{"type":"text","value":" with an image "},{"type":"text","value":123},{"type":"text","value":"."}]}]` in `#/my-input` does not match any given oneof schema',
+            },
+          ],
+        },
       );
     });
 
@@ -664,6 +867,34 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: Value `{"bad":"data"}` in `#/deep/arr/0/formattedTextArray/2` does not match any given oneof schema',
+        {
+          '#/deep/arr/0/formattedTextArray/2': [
+            {
+              data: {
+                errors: [
+                  {
+                    code: 'type-error',
+                    data: {
+                      expected: 'array',
+                      pointer: '#/deep/arr/0/formattedTextArray/2',
+                      received: 'object',
+                      value: { bad: 'data' },
+                    },
+                    message:
+                      'Expected `Object {"bad":"data"}` (object) in `#/deep/arr/0/formattedTextArray/2` to be of type `array`',
+                    name: 'TypeError',
+                    type: 'error',
+                  },
+                ],
+                oneOf: [{ $ref: 'FormattedText.json' }],
+                pointer: '#/deep/arr/0/formattedTextArray/2',
+                value: '{"bad":"data"}',
+              },
+              message:
+                'Value `{"bad":"data"}` in `#/deep/arr/0/formattedTextArray/2` does not match any given oneof schema',
+            },
+          ],
+        },
       );
     });
 
@@ -714,6 +945,27 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: Value `{"bad":"data"}` in `#/my-input` does not match any given oneof schema',
+        {
+          '#/my-input': [
+            {
+              data: {
+                errors: [
+                  {
+                    code: 'type-error',
+                    data: { expected: 'array', pointer: '#/my-input', received: 'object', value: { bad: 'data' } },
+                    message: 'Expected `Object {"bad":"data"}` (object) in `#/my-input` to be of type `array`',
+                    name: 'TypeError',
+                    type: 'error',
+                  },
+                ],
+                oneOf: [{ $ref: 'FormattedText.json' }],
+                pointer: '#/my-input',
+                value: '{"bad":"data"}',
+              },
+              message: 'Value `{"bad":"data"}` in `#/my-input` does not match any given oneof schema',
+            },
+          ],
+        },
       );
     });
 
@@ -801,6 +1053,14 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         `failed validation: Expected \`123\` (string) in \`#/my-input\` to be of type \`number\``,
+        {
+          '#/my-input': [
+            {
+              data: { expected: 'number', pointer: '#/my-input', received: 'string', value: '123' },
+              message: 'Expected `123` (string) in `#/my-input` to be of type `number`',
+            },
+          ],
+        },
       );
     });
 
@@ -812,6 +1072,11 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         `failed validation: The required property \`my-input\` is missing at \`#\``,
+        {
+          '#': [
+            { data: { key: 'my-input', pointer: '#' }, message: 'The required property `my-input` is missing at `#`' },
+          ],
+        },
       );
     });
 
@@ -825,6 +1090,14 @@ describe('JsonSchemaService', () => {
         },
         SchemaValidationError,
         'failed validation: Expected given value `z` in #/enum` to be one of `[a, b, c, d, e, ... 2 more]`',
+        {
+          '#/enum': [
+            {
+              data: { pointer: '#/enum', value: 'z', values: ['a', 'b', 'c', 'd', 'e', 'f', 'g'] },
+              message: 'Expected given value `z` in #/enum` to be one of `[a, b, c, d, e, ... 2 more]`',
+            },
+          ],
+        },
       );
     });
 

package/src/JsonValidationService.ts

@@ -67,6 +67,28 @@ const defaultConfig: DraftConfig = {
         data,
       };
     },
+
+    typeError(data) {
+      let value = `${data.value}`;
+
+      if (data.received == 'object') {
+        value = `Object ${JSON.stringify(data.value)}`;
+      }
+
+      if (data.received == 'array') {
+        value = `Array ${JSON.stringify(data.value)}`;
+      }
+
+      const expected = JSON.stringify(data.expected).replace(/"/g, '`');
+
+      return {
+        type: 'error',
+        name: 'TypeError',
+        code: 'type-error',
+        message: `Expected \`${value}\` (${data.received}) in \`${data.pointer}\` to be of type ${expected}`,
+        data,
+      };
+    },
   },
 };
 
@@ -204,15 +226,7 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
   public validateInput(input: unknown, inputSchema: JSONSchema = this.schema.rootSchema): true | never {
     inputSchema = this.schema.compileSchema(inputSchema);
     const errors = this.schema.validate(input, inputSchema);
-    return this.processValidationResult(errors);
-  }
-
-  private processValidationResult(errors: JSONError[]): true {
-    if (errors.length > 0) {
-      throw new SchemaValidationError(errors.map((a) => a.message).join(',\n'));
-    }
-
-    return true;
+    return processValidationResult(errors);
   }
 
   /**
@@ -269,7 +283,7 @@ export class JsonValidationService {
     switch (version) {
       case 'v1': {
         const validationResult = v1Schema.validate(manifest);
-        return this.processValidationResult(validationResult);
+        return processValidationResult(validationResult);
       }
 
       default:
@@ -277,37 +291,37 @@ export class JsonValidationService {
     }
   }
   validateContentSchema(contentSchema: JSONSchema) {
-    return this.processValidationResult(ComponentInputSchema.validate(contentSchema));
+    return processValidationResult(ComponentInputSchema.validate(contentSchema));
   }
 
   validateComponentInput(functionInputSchema: JSONSchema, inputValue: unknown) {
     const inputSchema = ComponentInputSchema.compileSchema(functionInputSchema);
     const errors = ComponentInputSchema.validate(inputValue, inputSchema);
-    return this.processValidationResult(errors);
+    return processValidationResult(errors);
   }
 
   validateRenderInput(functionInputSchema: JSONSchema, inputValue: unknown) {
     const inputSchema = RenderInputSchema.compileSchema(functionInputSchema);
     const errors = RenderInputSchema.validate(inputValue, inputSchema);
 
-    return this.processValidationResult(errors);
+    return processValidationResult(errors);
   }
+}
 
-  private processValidationResult(errors: JSONError[]): true {
-    if (errors.length > 0) {
-      const ValidationDataMap: ValidationDataMap = errors.reduce((acc: ValidationDataMap, error: JSONError) => {
-        const pointer = error?.data?.pointer;
-        const validationData: ValidationData = {
-          message: error.message,
-          data: error.data,
-        };
-        Object.keys(acc).includes(pointer) && Array.isArray(acc[pointer])
-          ? acc[pointer].push(validationData)
-          : (acc[pointer] = [validationData]);
-        return acc;
-      }, {});
-      throw new SchemaValidationError(errors.map((a) => a.message).join(',\n'), undefined, ValidationDataMap);
-    }
-    return true;
+function processValidationResult(errors: JSONError[]): true {
+  if (errors.length > 0) {
+    const ValidationDataMap: ValidationDataMap = errors.reduce((acc: ValidationDataMap, error: JSONError) => {
+      const pointer = error?.data?.pointer;
+      const validationData: ValidationData = {
+        message: error.message,
+        data: error.data,
+      };
+      Object.keys(acc).includes(pointer) && Array.isArray(acc[pointer])
+        ? acc[pointer].push(validationData)
+        : (acc[pointer] = [validationData]);
+      return acc;
+    }, {});
+    throw new SchemaValidationError(errors.map((a) => a.message).join(',\n'), undefined, ValidationDataMap);
   }
+  return true;
 }

package/src/validators/customFormatValidators.ts

@@ -1,6 +1,7 @@
 import { Draft, JSONError, JSONSchema } from '@squiz/json-schema-library';
 import { SchemaValidationError } from '../errors/SchemaValidationError';
 import { isMatrixAssetUri } from './utils/matrixAssetValidator';
+import { getValidationDataForMatrixUri } from './utils/getValidationDataForMatrixUri';
 
 export const customFormatValidators: Record<
   string,
@@ -8,7 +9,13 @@ export const customFormatValidators: Record<
 > = {
   'matrix-asset-uri': (core, schema, value): undefined => {
     if (isMatrixAssetUri(value) === false) {
-      throw new SchemaValidationError(`value "${value}" isn't a valid matrix asset uri`);
+      if (typeof value !== 'string') throw new SchemaValidationError(`matrix asset uri "${value}" isn't a string`);
+      const validationData = getValidationDataForMatrixUri(value);
+      throw new SchemaValidationError(
+        `matrix asset uri "${value}" isn't a valid matrix asset uri`,
+        undefined,
+        validationData,
+      );
     }
     return;
   },

package/src/validators/utils/getValidationDataForMatrixUri.spec.ts

@@ -0,0 +1,92 @@
+import { getValidationDataForMatrixUri } from './getValidationDataForMatrixUri';
+
+describe('getInvalidPartFromMatrixUri', () => {
+  it('should return invalid part of matrix asset uri - invalid scheme', () => {
+    const part = getValidationDataForMatrixUri('matrix-link://dx-data.asset.com/123');
+    expect(part).toEqual({
+      scheme: {
+        message: 'Uri scheme is invalid, must match "matrix-asset"',
+        data: {
+          expected: 'matrix-asset',
+          received: 'matrix-link',
+        },
+      },
+    });
+  });
+  it('should return invalid part of matrix asset uri - invalid identifier', () => {
+    const part = getValidationDataForMatrixUri('matrix-asset://dx team id/123');
+    expect(part).toEqual({
+      identifier: {
+        message: 'Matrix Identifier has invalid format, must match /^[a-zA-Z0-9.-]+$/',
+        data: {
+          expected: /^[a-zA-Z0-9.-]+$/,
+          received: 'dx team id',
+        },
+      },
+    });
+  });
+  it('should return invalid part of matrix asset uri - invalid asset id', () => {
+    const part = getValidationDataForMatrixUri('matrix-asset://dx-data.asset.com/asset/1234');
+    expect(part).toEqual({
+      assetId: {
+        message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
+        data: {
+          expected: /^\d+(?::.+)?$/,
+          received: 'asset/1234',
+        },
+      },
+    });
+  });
+
+  it('should return invalid part of matrix asset uri - invalid identifier and asset id', () => {
+    const part = getValidationDataForMatrixUri('matrix-asset://dx team id/asset/1234');
+    expect(part).toEqual({
+      identifier: {
+        message: 'Matrix Identifier has invalid format, must match /^[a-zA-Z0-9.-]+$/',
+        data: {
+          expected: /^[a-zA-Z0-9.-]+$/,
+          received: 'dx team id',
+        },
+      },
+      assetId: {
+        message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
+        data: {
+          expected: /^\d+(?::.+)?$/,
+          received: 'asset/1234',
+        },
+      },
+    });
+  });
+
+  it('should return invalid part of matrix asset uri - invalid scheme, identifier and asset id', () => {
+    const part = getValidationDataForMatrixUri('matrix-link://dx team id/asset/1234');
+    expect(part).toEqual({
+      scheme: {
+        message: 'Uri scheme is invalid, must match "matrix-asset"',
+        data: {
+          expected: 'matrix-asset',
+          received: 'matrix-link',
+        },
+      },
+      identifier: {
+        message: 'Matrix Identifier has invalid format, must match /^[a-zA-Z0-9.-]+$/',
+        data: {
+          expected: /^[a-zA-Z0-9.-]+$/,
+          received: 'dx team id',
+        },
+      },
+      assetId: {
+        message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
+        data: {
+          expected: /^\d+(?::.+)?$/,
+          received: 'asset/1234',
+        },
+      },
+    });
+  });
+
+  it('should return undefined if matrix asset uri is valid', () => {
+    const part = getValidationDataForMatrixUri('matrix-asset://dx-data.asset.com/123');
+    expect(part).toEqual(undefined);
+  });
+});

package/src/validators/utils/getValidationDataForMatrixUri.ts

@@ -0,0 +1,55 @@
+type matrixAssetUriValidationData = { message: string; data: any };
+type uriParts = 'scheme' | 'identifier' | 'assetId';
+type matrixAssetUriValidationDataMap = Record<uriParts, matrixAssetUriValidationData> | object;
+
+export function getValidationDataForMatrixUri(uri: string): matrixAssetUriValidationDataMap | undefined {
+  let validationDataMap: matrixAssetUriValidationDataMap = {};
+  const [scheme, path] = uri.split('://');
+
+  if (scheme !== 'matrix-asset') {
+    const validationData: matrixAssetUriValidationData = {
+      message: 'Uri scheme is invalid, must match "matrix-asset"',
+      data: {
+        expected: 'matrix-asset',
+        received: scheme,
+      },
+    };
+    validationDataMap = {
+      ...validationDataMap,
+      scheme: validationData,
+    };
+  }
+
+  const [identifier, ...assetIdArray] = path.split('/');
+  const assetId = assetIdArray.join('/');
+
+  const identifierRegex = /^[a-zA-Z0-9.-]+$/;
+  if (identifierRegex.test(identifier) === false) {
+    validationDataMap = {
+      ...validationDataMap,
+      identifier: {
+        message: 'Matrix Identifier has invalid format, must match /^[a-zA-Z0-9.-]+$/',
+        data: {
+          expected: /^[a-zA-Z0-9.-]+$/,
+          received: identifier,
+        },
+      },
+    };
+  }
+
+  const assetIdRegex = /^\d+(?::.+)?$/;
+  if (assetIdRegex.test(assetId) === false) {
+    validationDataMap = {
+      ...validationDataMap,
+      assetId: {
+        message: 'Matrix Asset Id has invalid format, must match /^d+(?::.+)?$/',
+        data: {
+          expected: /^\d+(?::.+)?$/,
+          received: assetId,
+        },
+      },
+    };
+  }
+
+  return Object.keys(validationDataMap).length > 0 ? validationDataMap : undefined;
+}