@squiz/dx-json-schema-lib 1.12.0-alpha.8 → 1.12.1-alpha.0

package/lib/manifest/v1/v1.spec.js

@@ -4,6 +4,7 @@ const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const SchemaValidationError_1 = require("../../errors/SchemaValidationError");
 const JsonValidationService_1 = require("../../JsonValidationService");
+const NAME_PATTERN = '^[a-z][a-z0-9_\\-]+$';
 async function fetchTestManifest(filename) {
     const contents = await (0, promises_1.readFile)((0, path_1.resolve)(__dirname, '__test__', 'schemas', filename), {
         encoding: 'utf-8',
@@ -50,5 +51,62 @@ describe('manifest/v1', () => {
             validationService.validateManifest(manifest, 'v1');
         }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Expected value at `#/functions/0/input/type` to be `object`, but value given is `string`');
     });
+    describe.each(['_my-name', '-my-name', 'MyName', 'myName', '0my-name'])('fails name-pattern validation for %s', (propertyValue) => {
+        it.each(['namespace', 'name'])(`fails validation for manifests with %s of %s`, async (propertyName) => {
+            const manifest = await fetchTestManifest('validComponent.json');
+            expectToThrowErrorMatchingTypeAndMessage(() => {
+                validationService.validateManifest({
+                    ...manifest,
+                    [propertyName]: propertyValue,
+                }, 'v1');
+            }, SchemaValidationError_1.SchemaValidationError, `failed validation: Value in \`#/${propertyName}\` should match \`${NAME_PATTERN}\`, but received \`${propertyValue}\``);
+        });
+        it('fails validation for manifests with function names of %s', async () => {
+            const manifest = await fetchTestManifest('validComponent.json');
+            expectToThrowErrorMatchingTypeAndMessage(() => {
+                validationService.validateManifest({
+                    ...manifest,
+                    functions: [
+                        {
+                            name: propertyValue,
+                            entry: 'main.js',
+                            input: {},
+                            output: {
+                                responseType: 'html',
+                            },
+                        },
+                    ],
+                }, 'v1');
+            }, SchemaValidationError_1.SchemaValidationError, `failed validation: Value in \`#/functions/0/name\` should match \`${NAME_PATTERN}\`, but received \`${propertyValue}\``);
+        });
+    });
+    it('should allow uppercase letters in property names withe previews', async () => {
+        const manifest = await fetchTestManifest('validComponent.json');
+        expect(validationService.validateManifest({
+            ...manifest,
+            previews: {
+                ValidPreview: {
+                    functionData: {
+                        main: {},
+                    },
+                },
+            },
+        }, 'v1')).toEqual(true);
+    });
+    it('errors for non-alphanumeric characters in preview keys', async () => {
+        const manifest = await fetchTestManifest('validComponent.json');
+        expectToThrowErrorMatchingTypeAndMessage(() => {
+            validationService.validateManifest({
+                ...manifest,
+                previews: {
+                    'Bad-@@@Preview': {
+                        functionData: {
+                            main: {},
+                        },
+                    },
+                },
+            }, 'v1');
+        }, SchemaValidationError_1.SchemaValidationError, 'failed validation: Invalid property name `Bad-@@@Preview` at `#/previews`');
+    });
 });
 //# sourceMappingURL=v1.spec.js.map

package/lib/manifest/v1/v1.spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"v1.spec.js","sourceRoot":"","sources":["../../../src/manifest/v1/v1.spec.ts"],"names":[],"mappings":";;AAAA,0CAAuC;AACvC,+BAA+B;AAC/B,8EAA2E;AAC3E,uEAAoE;AAEpE,KAAK,UAAU,iBAAiB,CAAC,QAAgB;IAC/C,MAAM,QAAQ,GAAG,MAAM,IAAA,mBAAQ,EAAC,IAAA,cAAO,EAAC,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE;QACnF,QAAQ,EAAE,OAAO;KAClB,CAAC,CAAC;IACH,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;AAC9B,CAAC;AACD,wDAAwD;AACxD,SAAS,wCAAwC,CAAC,QAAkB,EAAE,SAAmB,EAAE,OAAe;IACxG,IAAI,KAAK,GAAiB,IAAI,CAAC;IAE/B,IAAI;QACF,QAAQ,EAAE,CAAC;KACZ;IAAC,OAAO,CAAM,EAAE;QACf,KAAK,GAAG,CAAC,CAAC;KACX;IAED,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IAC5B,MAAM,CAAC,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACxC,MAAM,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;AAC1C,CAAC;AAED,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,IAAI,iBAAwC,CAAC;IAE7C,SAAS,CAAC,GAAG,EAAE;QACb,iBAAiB,GAAG,IAAI,6CAAqB,EAAE,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8BAA8B,EAAE,KAAK,IAAI,EAAE;QAC5C,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;QAChE,MAAM,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oDAAoD,EAAE,KAAK,IAAI,EAAE;QAClE,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,gCAAgC,CAAC,CAAC;QAE3E,wCAAwC,CACtC,GAAG,EAAE;YACH,iBAAiB,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC,EACD,6CAAqB,EACrB,sHAAsH,CACvH,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,KAAK,IAAI,EAAE;QACzE,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,6BAA6B,CAAC,CAAC;QAExE,wCAAwC,CACtC,GAAG,EAAE;YACH,iBAAiB,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC,EACD,6CAAqB,EACrB,+HAA+H,CAChI,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,QAAQ,GAAG,MAAM,iBAAiB,CAAC,sCAAsC,CAAC,CAAC;QACjF,wCAAwC,CACtC,GAAG,EAAE;YACH,iBAAiB,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC,EACD,6CAAqB,EACrB,6GAA6G,CAC9G,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}
+{"version":3,"file":"v1.spec.js","sourceRoot":"","sources":["../../../src/manifest/v1/v1.spec.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dx-json-schema-lib",
-  "version": "1.12.0-alpha.8",
+  "version": "1.12.1-alpha.0",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
@@ -20,14 +20,15 @@
     "jest": "29.4.1",
     "json-schema-to-typescript": "11.0.3",
     "rimraf": "4.1.2",
-    "ts-jest": "28.0.8",
+    "ts-jest": "29.0.5",
     "ts-loader": "9.3.1",
     "ts-node": "10.9.1",
     "typescript": "4.9.4"
   },
   "dependencies": {
     "@sagold/json-query": "6.0.0",
-    "json-schema-library": "7.4.5"
+    "json-schema-library": "7.4.5",
+    "ts-brand": "0.0.2"
   },
-  "gitHead": "3a835dd86ed757cb28f4fc51a80114215f4fea41"
+  "gitHead": "4a0c81e76ca50706d137dee82869e3ea7844376e"
 }

package/src/JsonValidationService.spec.ts

@@ -1,9 +1,11 @@
-import { JsonValidationService } from './JsonValidationService';
+import { ComponentInputMetaSchema, JSONSchemaService, 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';
+import { JSONSchema } from 'json-schema-library';
+import { PrimitiveType, ResolvableType, TypeResolver } from './jsonTypeResolution/arbitraryTypeResolution';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 function expectToThrowErrorMatchingTypeAndMessage(received: Function, errorType: Function, message: string) {
@@ -448,6 +450,60 @@ describe('JsonValidationService', () => {
           'failed validation: Expected `[object Object]` (object) in `#/my-input` to be of type `array`',
         );
       });
+
+      it('should validate a FormattedText value when the schema is a $ref to a $ref', async () => {
+        const formattedText: FormattedText = [
+          {
+            tag: 'p',
+            type: 'tag',
+            children: [{ type: 'text', value: 'hello' }],
+          },
+        ];
+
+        const schema = {
+          type: 'object',
+          properties: {
+            'my-input': { $ref: '#/definitions/FormattedText' },
+          },
+          definitions: {
+            FormattedText: { $ref: '#/definitions/FormattedText2' },
+            FormattedText2: { type: 'FormattedText' },
+          },
+          required: ['my-input'],
+        };
+        const value = {
+          'my-input': formattedText,
+        };
+
+        expect(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
+      });
+
+      it('should validate a FormattedText value when the schema is in an if/then/else', async () => {
+        const formattedText: FormattedText = [
+          {
+            tag: 'p',
+            type: 'tag',
+            children: [{ type: 'text', value: 'hello' }],
+          },
+        ];
+
+        const schema = {
+          type: 'object',
+          properties: {
+            'my-input': {
+              if: { type: 'string' },
+              then: { type: 'string' },
+              else: { type: 'FormattedText' },
+            },
+          },
+          required: ['my-input'],
+        };
+        const value = {
+          'my-input': formattedText,
+        };
+
+        expect(jsonValidationService.validateComponentInput(schema, value)).toEqual(true);
+      });
     });
 
     describe('standard inputs', () => {
@@ -518,4 +574,364 @@ describe('JsonValidationService', () => {
       });
     });
   });
+
+  describe('validateRenderInput', () => {
+    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', () => {
+  describe('validateInput', () => {
+    it.each([String('123'), Number(123), [123]])(
+      'should validate any primitive type with its resolvable type %s',
+      (propertyValue) => {
+        const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+        const jsonSchemaService = new 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(''),
+              },
+            },
+          ),
+          ComponentInputMetaSchema,
+        );
+
+        expect(
+          jsonSchemaService.validateInput(
+            { myProperty: propertyValue },
+            { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+          ),
+        ).toEqual(true);
+      },
+    );
+
+    it('should error when a primitive type is provided a value that cannot be resolved by its resolvable types', () => {
+      const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+      const 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(''),
+            },
+          },
+        ),
+        ComponentInputMetaSchema,
+      );
+
+      expect(() => {
+        jsonSchemaService.validateInput(
+          { myProperty: true },
+          { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+        );
+      }).toThrowError();
+    });
+
+    it.each([String('123'), Number(123), [123]])(
+      'should validate a primitive type when defined as a ref with resolvable value %s',
+      (propertyValue) => {
+        const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+        const 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(''),
+              },
+            },
+          ),
+          ComponentInputMetaSchema,
+        );
+
+        expect(
+          jsonSchemaService.validateInput(
+            { myProperty: propertyValue },
+            {
+              type: 'object',
+              properties: { myProperty: { $ref: '#/definitions/Ref' } },
+              definitions: { Ref: { type: 'MyPrimitive' } },
+            },
+          ),
+        ).toEqual(true);
+      },
+    );
+
+    it('should not validate on a primitive type against a resolvable type when a resolver is not defined', () => {
+      const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+      const jsonSchemaService = new JSONSchemaService(
+        new TypeResolver(
+          {
+            MyPrimitive: primitiveSchema,
+          },
+          {
+            MyResolvableNumber: resolvableTypeFixture('MyResolvableNumber', { type: 'number' }),
+            MyResolvableArray: resolvableTypeFixture('MyResolvableArray', { type: 'array' }),
+          },
+          {
+            MyPrimitive: {
+              MyResolvableNumber: (value: number) => value.toString(),
+            },
+          },
+        ),
+        ComponentInputMetaSchema,
+      );
+
+      expect(() => {
+        jsonSchemaService.validateInput(
+          { myProperty: [123] },
+          { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+        );
+      }).toThrowError();
+    });
+
+    it('should validate a primitive type against similar but different resolvable types', () => {
+      const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+      const jsonSchemaService = new JSONSchemaService(
+        new TypeResolver(
+          {
+            MyPrimitive: primitiveSchema,
+          },
+          {
+            MyResolvableSrcNumber: resolvableTypeFixture('MyResolvableSrcNumber', {
+              type: 'object',
+              properties: {
+                src: { type: 'number' },
+              },
+            }),
+            MyResolvableSrcString: resolvableTypeFixture('MyResolvableSrcString', {
+              type: 'object',
+              properties: {
+                src: { type: 'string' },
+              },
+            }),
+          },
+          {
+            MyPrimitive: {
+              MyResolvableSrcNumber: (value: { src: number }) => value.src.toString(),
+              MyResolvableSrcString: (value: { src: string }) => value.src,
+            },
+          },
+        ),
+        ComponentInputMetaSchema,
+      );
+
+      expect(
+        jsonSchemaService.validateInput(
+          {
+            myProperty: {
+              src: 123,
+            },
+          },
+          { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+        ),
+      ).toEqual(true);
+      expect(
+        jsonSchemaService.validateInput(
+          {
+            myProperty: {
+              src: '123',
+            },
+          },
+          { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+        ),
+      ).toEqual(true);
+    });
+  });
+
+  describe('resolveInput', () => {
+    it.each([String('123'), Number(123), [123]])(
+      'should resolve a primitive type from its resolvable type %s',
+      async (resolvableValue) => {
+        const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+        const jsonSchemaService = new 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(''),
+              },
+            },
+          ),
+          ComponentInputMetaSchema,
+        );
+
+        await expect(
+          jsonSchemaService.resolveInput(
+            { myProperty: resolvableValue },
+            { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+          ),
+        ).resolves.toEqual({ myProperty: '123' });
+      },
+    );
+
+    it.each([
+      [{ src: 'MyString' }, 'MyString'],
+      [{ src: 1132 }, '1132'],
+    ])('should resolve a resolvable type %s against the correct resolver to %s', async (resolvableValue, output) => {
+      const primitiveSchema = primitiveTypeFixture('MyPrimitive', { type: 'string' });
+      const jsonSchemaService = new JSONSchemaService(
+        new TypeResolver(
+          {
+            MyPrimitive: primitiveSchema,
+          },
+          {
+            MyResolvableSrcString: resolvableTypeFixture('MyResolvableSrcString', {
+              type: 'object',
+              properties: { src: { type: 'string' } },
+            }),
+            MyResolvableSrcNumber: resolvableTypeFixture('MyResolvableSrcNumber', {
+              type: 'object',
+              properties: { src: { type: 'number' } },
+            }),
+          },
+          {
+            MyPrimitive: {
+              MyResolvableSrcNumber: (value: { src: number }) => value.src.toString(),
+              MyResolvableSrcString: (value: { src: string }) => value.src,
+            },
+          },
+        ),
+        ComponentInputMetaSchema,
+      );
+
+      await expect(
+        jsonSchemaService.resolveInput(
+          { myProperty: resolvableValue },
+          { type: 'object', properties: { myProperty: { type: 'MyPrimitive' } } },
+        ),
+      ).resolves.toEqual({ myProperty: output });
+    });
+  });
 });