@squiz/dx-json-schema-lib 1.79.0 → 1.80.0

package/src/JsonValidationService.ts

@@ -1,31 +1,46 @@
-import JSONQuery, { Input } from '@sagold/json-query';
-
 import DxComponentInputSchema from './manifest/v1/DxComponentInputSchema.json';
-import DxComponentIcons from './manifest/v1/DxComponentIcons.json';
 import DxContentMetaSchema from './manifest/v1/DxContentMetaSchema.json';
-import MatrixAssetSchema from './manifest/v1/MatrixAssetSchema.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 JobV1 from './manifest/v1/JobV1.json';
-import { SchemaValidationError, ValidationData, ValidationDataMap } from './errors/SchemaValidationError';
-import { Draft07, JSONError, JSONSchema, Draft, DraftConfig } from '@squiz/json-schema-library';
+import { SchemaValidationError } from './errors/SchemaValidationError';
+import { Draft07, JSONSchema, Draft, DraftConfig } from '@squiz/json-schema-library';
 
 import { draft07Config } from '@squiz/json-schema-library';
-import { MANIFEST_MODELS } from '.';
+import {
+  BaseFormattedTextType,
+  ComponentInputFormattedTextType,
+  MANIFEST_MODELS,
+  SquizImageType,
+  SquizLinkType,
+  TypeResolverBuilder,
+} from '.';
 import { customFormatValidators } from './validators/customFormatValidators';
-import { AnyPrimitiveType, AnyResolvableType, TypeResolver } from './jsonTypeResolution/TypeResolver';
-import { JsonResolutionError } from './errors/JsonResolutionError';
-
-const defaultConfig: DraftConfig = {
+import { customKeywordValidators } from './validators/customKeywordValidators';
+import {
+  ComponentInputMetaSchema,
+  JobV1MetaSchema,
+  JSONSchemaService,
+  ManifestV1MetaSchema,
+} from './JsonSchemaService';
+
+export const defaultConfig: DraftConfig = {
   ...draft07Config,
   validateFormat: {
     ...draft07Config.validateFormat,
     ...customFormatValidators,
   },
+  typeKeywords: {
+    ...draft07Config.typeKeywords,
+    array: draft07Config.typeKeywords.array.concat('ui:metadata'),
+    object: draft07Config.typeKeywords.object.concat('ui:metadata'),
+    boolean: draft07Config.typeKeywords.boolean.concat('ui:metadata'),
+    string: draft07Config.typeKeywords.string.concat('ui:metadata'),
+    number: draft07Config.typeKeywords.number.concat('ui:metadata'),
+  },
+  validateKeyword: {
+    ...draft07Config.validateKeyword,
+    ...customKeywordValidators,
+  },
   errors: {
     ...draft07Config.errors,
     enumError(data) {
@@ -95,6 +110,9 @@ const defaultConfig: DraftConfig = {
 
 const FTSchema = new Draft07(FormattedText, defaultConfig);
 
+/**
+ * @deprecated Only used for FormattedText resolution
+ */
 export const ComponentInputSchema = new Draft(
   {
     ...defaultConfig,
@@ -122,236 +140,56 @@ export const ComponentInputSchema = new Draft(
 );
 ComponentInputSchema.addRemoteSchema('DxComponentInputSchema.json/DxContentMetaSchema.json', DxContentMetaSchema);
 
-export const RenderInputSchema = 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 { type: 'string' };
-    } else if (Array.isArray(resolvedSchema.type) && resolvedSchema.type.includes('FormattedText')) {
-      return {
-        ...schema,
-        type: resolvedSchema.type.filter((t) => t !== 'FormattedText').concat('string'),
-      };
-    } else {
-      return resolvedSchema;
-    }
-  },
-});
-
-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('/MatrixAssetSchema.json', MatrixAssetSchema);
-v1Schema.addRemoteSchema('http://json-schema.org/draft-07/schema', Draft07Schema);
-v1Schema.addRemoteSchema('http://json-schema.org/draft-07/schema#', Draft07Schema);
-
-const jobV1Schema = new Draft07(JobV1, defaultConfig);
-jobV1Schema.addRemoteSchema('/DxComponentInputSchema.json', ComponentInputSchema.getSchema());
-
-export const ComponentInputMetaSchema: MetaSchemaInput = {
-  root: DxComponentInputSchema,
-  remotes: {
-    'DxComponentInputSchema.json/DxContentMetaSchema.json': DxContentMetaSchema,
-  },
-};
-
-export const RenderInputMetaSchema: MetaSchemaInput = {
-  root: Draft07Schema,
-};
-
-export const ManifestV1MetaSchema: MetaSchemaInput = {
-  root: v1,
-  remotes: {
-    'DxComponentInputSchema.json/DxContentMetaSchema.json': DxContentMetaSchema,
-    '/DxComponentInputSchema.json': DxComponentInputSchema,
-    '/DxComponentIcons.json': DxComponentIcons,
-    '/MatrixAssetSchema.json': MatrixAssetSchema,
-    'http://json-schema.org/draft-07/schema': Draft07Schema,
-    'http://json-schema.org/draft-07/schema#': Draft07Schema,
-  },
-};
-
-interface MetaSchemaInput {
-  root: JSONSchema;
-  remotes?: Record<string, JSONSchema>;
-}
 /**
- * A service that can be used to validate and resolve JSON against a schema.
+ * Deprecated JSON Validation Service that wraps the JSONSchemaService
+ * @deprecated Use JSONSchemaService instead
  */
-export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvableType> {
-  schema: Draft;
-  constructor(private typeResolver: TypeResolver<P, R>, metaSchema: MetaSchemaInput) {
-    this.schema = new Draft(
-      {
-        ...defaultConfig,
-        resolveRef: (schema, rootSchema) => this.doResolveRef(schema, rootSchema),
-        validate: (core, data, schema, pointer) => defaultConfig.validate(core, data, schema, pointer),
-        resolveOneOf: (core, data, schema, pointer) => defaultConfig.resolveOneOf(core, data, schema, pointer),
-      },
-      metaSchema.root,
-    );
-
-    for (const [key, value] of Object.entries(metaSchema.remotes || {})) {
-      this.schema.addRemoteSchema(key, value);
-    }
-
-    for (const schema of this.typeResolver.validationSchemaDefinitions) {
-      // Please find a better way of doing this.
-      this.schema.addRemoteSchema(`/${schema.title}.json`, schema as JSONSchema);
-      this.schema.addRemoteSchema(`#/${schema.title}.json`, schema as JSONSchema);
-    }
-  }
-
-  private doResolveRef(schema: JSONSchema, rootSchema: JSONSchema): JSONSchema {
-    const initialRef = draft07Config.resolveRef(schema, rootSchema);
-    if (!initialRef) return initialRef;
-    if (!this.typeResolver.isPrimitiveType(initialRef.type)) return initialRef;
-
-    const validationSchemas = this.typeResolver.getValidationSchemaForPrimitive(initialRef.type);
-    // All validation schemas are pre-compiled as remote schemas and are referenced below
-    const fullValidationSchema = {
-      oneOf: validationSchemas.map((schema) => ({ $ref: `${schema.title}.json` })),
-    };
-    return this.schema.compileSchema(fullValidationSchema);
-  }
-
-  /**
-   * Validate an input value against a specified schema
-   * @throws {SchemaValidationError} if the input is invalid
-   * @returns true if the input is valid
-   */
-  public validateInput(input: unknown, inputSchema: JSONSchema = this.schema.rootSchema): true | never {
-    inputSchema = this.schema.compileSchema(inputSchema);
-    const errors = this.schema.validate(input, inputSchema);
-    return processValidationResult(errors);
-  }
-
-  /**
-   * Resolve an input object by replacing all resolvable shapes with their resolved values
-   * @param input any input object which matches the input schema
-   * @param inputSchema a JSONSchema which provides type information about the input object
-   * @returns the input object with all resolvable shapes resolved
-   */
-  public async resolveInput(input: Input, inputSchema: JSONSchema) {
-    const setters: Array<Promise<(input: Input) => Input>> = [];
-    this.schema.each(
-      input,
-      async (schema, value, pointer) => {
-        // Bug in library for Array item schemas which won't resolve the oneOf schema
-        if (Array.isArray(schema?.oneOf)) {
-          const oldSchema = schema;
-          schema = this.schema.resolveOneOf(value, schema);
-          schema.oneOfSchema = oldSchema;
-        }
-        if (!this.typeResolver.isResolvableSchema(schema)) return;
-        // If its a resolvable schema, it should exist in a oneOf array with other schemas
-        // Including a primitive schema
-        const allPossibleSchemaTitles: Array<string> = schema.oneOfSchema.oneOf.map((o: JSONSchema) =>
-          o.$ref.replace('.json', ''),
-        );
-        const primitiveSchema = allPossibleSchemaTitles.find((title) => this.typeResolver.isPrimitiveType(title));
-        if (!primitiveSchema) return;
-        const resolver = this.typeResolver.tryGetResolver(primitiveSchema, schema as any);
-        if (!resolver) return;
-        const setResolvedData = Promise.resolve()
-          .then(() => resolver(value))
-          .then((resolvedData) => (item: typeof input) => JSONQuery.set(item, pointer, resolvedData, 'replace' as any))
-          .catch((e) => Promise.reject(new JsonResolutionError(e, pointer, value)));
-        setters.push(setResolvedData);
-      },
-      inputSchema,
-    );
-
-    const potentialResolutionErrors = [];
-    for (const resolveResult of await Promise.allSettled(setters)) {
-      if (resolveResult.status === 'rejected') {
-        potentialResolutionErrors.push(resolveResult.reason);
-        continue;
-      }
-
-      input = resolveResult.value(input);
-    }
-    if (potentialResolutionErrors.length) {
-      throw new Error(`Error(s) occurred when resolving JSON:\n${potentialResolutionErrors.join('\n')}`);
-    }
-    return input;
-  }
-
-  private assignResolvedData(input: Input, pointer: string, resolvedData: unknown): Input {
-    // TODO: Revert to using JSONQuery.set once https://github.com/sagold/json-query/pull/27 is resolved.
-    // Test "should resolve multiple primitive type array items in multi-level nested array structures" confirms
-    // desired behaviour.
-    JSONQuery.get(input, pointer, (unresolvedData) => {
-      if (resolvedData === unresolvedData) {
-        return;
-      }
-
-      for (const prop of Object.getOwnPropertyNames(unresolvedData)) {
-        delete unresolvedData[prop];
-      }
-
-      Object.assign(unresolvedData, resolvedData);
-    });
-
-    return input;
-  }
-}
-
 export class JsonValidationService {
+  private jobSchemaService = new JSONSchemaService(TypeResolverBuilder.new().build(), JobV1MetaSchema);
+  private componentInputSchemaService = new JSONSchemaService(
+    TypeResolverBuilder.new()
+      .addPrimitive(BaseFormattedTextType)
+      .addPrimitive(SquizImageType)
+      .addPrimitive(SquizLinkType)
+      .build(),
+    ComponentInputMetaSchema,
+  );
+  private renderInputSchemaService = new JSONSchemaService(
+    TypeResolverBuilder.new()
+      .addPrimitive(ComponentInputFormattedTextType)
+      .addPrimitive(SquizImageType)
+      .addPrimitive(SquizLinkType)
+      .build(),
+    ComponentInputMetaSchema,
+  );
+  private componentManifestSchemaService = new JSONSchemaService(
+    TypeResolverBuilder.new().build(),
+    ManifestV1MetaSchema,
+  );
+
   validateManifest(manifest: unknown, version: 'v1' | 'JobV1') {
     switch (version) {
       case 'v1': {
-        const validationResult = v1Schema.validate(manifest);
-        return processValidationResult(validationResult);
+        return this.componentManifestSchemaService.validateInput(manifest);
       }
       case 'JobV1': {
-        const validationResult = jobV1Schema.validate(manifest);
-        return processValidationResult(validationResult);
+        return this.jobSchemaService.validateInput(manifest);
       }
 
       default:
         throw new SchemaValidationError('Invalid manifest version');
     }
   }
+
   validateContentSchema(contentSchema: JSONSchema) {
-    return processValidationResult(ComponentInputSchema.validate(contentSchema));
+    return this.componentInputSchemaService.validateInput(contentSchema);
   }
 
   validateComponentInput(functionInputSchema: JSONSchema, inputValue: unknown) {
-    const inputSchema = ComponentInputSchema.compileSchema(functionInputSchema);
-    const errors = ComponentInputSchema.validate(inputValue, inputSchema);
-    return processValidationResult(errors);
+    return this.componentInputSchemaService.validateInput(inputValue, functionInputSchema);
   }
 
   validateRenderInput(functionInputSchema: JSONSchema, inputValue: unknown) {
-    const inputSchema = RenderInputSchema.compileSchema(functionInputSchema);
-    const errors = RenderInputSchema.validate(inputValue, inputSchema);
-
-    return processValidationResult(errors);
-  }
-}
-
-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 this.renderInputSchemaService.validateInput(inputValue, functionInputSchema);
   }
-  return true;
 }

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './formatted-text/v1/resolveFormattedTextNodes';
 
 export * as SUB_SCHEMAS from './manifest/v1/subSchemas';
 
+export * from './JsonSchemaService';
 export * from './JsonValidationService';
 export * from './errors/SchemaValidationError';
 export * from './errors/JsonResolutionError';

package/src/jsonTypeResolution/TypeResolver.spec.ts

@@ -84,4 +84,16 @@ describe('getValidationSchemaForPrimitive', () => {
         }),
     ).toThrowError();
   });
+
+  it('should return undefined when try to get a resolver for missing primitive', () => {
+    const primitiveType = primitiveTypeFixture('MyPrimitive');
+    const resolvableType = resolvableTypeFixture('MyResolvable');
+    const resolver = new TypeResolver([primitiveType, primitiveTypeFixture('MyOtherPrimitive')], [resolvableType], {
+      MyOtherPrimitive: {
+        MyResolvable: () => null,
+      },
+    });
+
+    expect(resolver.tryGetResolver('DoesNotExist', resolvableType)).toEqual(undefined);
+  });
 });

package/src/jsonTypeResolution/TypeResolver.ts

@@ -74,10 +74,6 @@ export class TypeResolver<P extends AnyPrimitiveType, R extends AnyResolvableTyp
     return this.primitives.has(type);
   }
 
-  isPrimitiveSchema(schema: JSONSchema): schema is P {
-    return this.isPrimitiveType(schema.title);
-  }
-
   isResolvableSchema(schema: JSONSchema): schema is R {
     return this.resolvables.has(schema.title);
   }

package/src/manifest/v1/DxComponentInputSchema.spec.ts

@@ -161,4 +161,25 @@ describe('DxComponentInputSchema', () => {
       }),
     ).not.toThrowError();
   });
+
+  describe('ui:metadata', () => {
+    describe('enumWidget', () => {
+      it.each(['radio', 'dropdown'])('should allow %s as a value', (v) => {
+        expect(() =>
+          jsonValidationService.validateContentSchema({
+            type: 'object',
+            required: [],
+            properties: {
+              myProp: {
+                enum: ['one', 'two', 'three'],
+                'ui:metadata': {
+                  enumWidget: v,
+                },
+              },
+            },
+          }),
+        ).not.toThrow();
+      });
+    });
+  });
 });

package/src/manifest/v1/DxContentMetaSchema.json

@@ -36,43 +36,34 @@
       "default": []
     },
     "ui:metadata": {
-      "oneOf": [
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "collapsedByDefault": {
-              "type": "boolean",
-              "default": false
-            }
-          },
-          "if": {
-            "type": "object"
-          }
-        },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "inlineEditable": {
-              "type": "boolean",
-              "default": false
-            },
-            "quickOption": {
-              "type": "boolean",
-              "default": false
-            }
-          },
-          "if": {
-            "type": ["number", "integer", "array", "boolean", "string"]
-          }
-        }
-      ],
+      "type": "object",
+      "additionalProperties": false,
       "properties": {
         "autoReload": {
           "type": "boolean",
           "description": "Whether the component should automatically reload when the input is changed",
           "default": false
+        },
+        "inlineEditable": {
+          "type": "boolean",
+          "default": false,
+          "description": "Allow this property to be editable inline"
+        },
+        "collapsedByDefault": {
+          "type": "boolean",
+          "default": false,
+          "description": "Choose if an object grouping should be collapsed by default"
+        },
+        "quickOption": {
+          "type": "boolean",
+          "default": false,
+          "description": "Allow this property to be part of the Quick Options UI"
+        },
+        "enumWidget": {
+          "type": "string",
+          "enum": ["radio", "dropdown"],
+          "default": "dropdown",
+          "description": "Choose if the enum values are displayed as a radio button list or a dropdown"
         }
       }
     }
@@ -231,6 +222,7 @@
     "oneOf": { "$ref": "#/definitions/schemaArray" },
     "not": { "$ref": "#" }
   },
+  "ui:metadata": { "$ref": "#/definitions/ui:metadata" },
   "additionalProperties": false,
   "dependencies": {
     "properties": {

package/src/manifest/v1/JobV1.ts

@@ -14,32 +14,10 @@ export type DxComponentInputSchema = CoreSchemaMetaSchema & {
   [k: string]: unknown;
 };
 export type CoreSchemaMetaSchema = CoreSchemaMetaSchema1 & CoreSchemaMetaSchema2;
-export type UiMetadata = {
-  /**
-   * Whether the component should automatically reload when the input is changed
-   */
-  autoReload?: boolean;
-  [k: string]: unknown;
-} & (
-  | {
-      collapsedByDefault?: boolean;
-    }
-  | {
-      inlineEditable?: boolean;
-      quickOption?: boolean;
-    }
-);
 export type CoreSchemaMetaSchema2 =
   | {
       $id?: string;
-      'ui:metadata'?:
-        | {
-            collapsedByDefault?: boolean;
-          }
-        | {
-            inlineEditable?: boolean;
-            quickOption?: boolean;
-          };
+      'ui:metadata'?: UiMetadata;
       $schema?: string;
       $ref?: string;
       $comment?: string;
@@ -469,3 +447,25 @@ export interface CoreSchemaMetaSchema1 {
   oneOf?: SchemaArray;
   not?: CoreSchemaMetaSchema2;
 }
+export interface UiMetadata {
+  /**
+   * Whether the component should automatically reload when the input is changed
+   */
+  autoReload?: boolean;
+  /**
+   * Allow this property to be editable inline
+   */
+  inlineEditable?: boolean;
+  /**
+   * Choose if an object grouping should be collapsed by default
+   */
+  collapsedByDefault?: boolean;
+  /**
+   * Allow this property to be part of the Quick Options UI
+   */
+  quickOption?: boolean;
+  /**
+   * Choose if the enum values are displayed as a radio button list or a dropdown
+   */
+  enumWidget?: 'radio' | 'dropdown';
+}

package/src/manifest/v1/__test__/schemas/invalidUiMetadata.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "../../v1.json",
+  "description": "t",
+  "displayName": "t",
+  "name": "test",
+  "namespace": "other",
+  "mainFunction": "main",
+  "version": "1.0.4",
+  "environment": [],
+  "functions": [
+    {
+      "entry": "main.js",
+      "name": "main",
+      "output": {
+        "responseType": "html"
+      },
+      "input": {
+        "type": "object",
+        "properties": {
+          "prop": {
+            "type": "string",
+            "ui:metadata": {
+              "quickOption": true
+            }
+          }
+        },
+        "required": []
+      }
+    }
+  ]
+}

package/src/manifest/v1/v1.spec.ts

@@ -21,9 +21,9 @@ function expectToThrowErrorMatchingTypeAndMessage(received: Function, errorType:
     error = e;
   }
 
-  expect(error).toBeDefined();
-  expect(error?.message).toEqual(message);
+  expect(error).toBeTruthy();
   expect(error).toBeInstanceOf(errorType);
+  expect(error?.message).toEqual(message);
 }
 
 describe('manifest/v1', () => {
@@ -276,76 +276,6 @@ describe('manifest/v1', () => {
       ),
     ).toEqual(true);
   });
-  it('should fail if ui:metadata property object on object input group has flags other than collapsedByDefault', async () => {
-    const manifest = await fetchTestManifest('validComponent.json');
-    expectToThrowErrorMatchingTypeAndMessage(
-      () => {
-        validationService.validateManifest(
-          {
-            ...manifest,
-            functions: [
-              {
-                name: 'main',
-                entry: 'main.js',
-                output: {
-                  responseType: 'html',
-                },
-                input: {
-                  type: 'object',
-                  properties: {
-                    'users-contact': {
-                      type: 'object',
-                      description: 'A description of group can be provided if needed',
-                      required: ['fist-name', 'last-name', 'phone-number', 'email'],
-                      'ui:metadata': {
-                        collapsedByDefault: true,
-                        quickOption: false,
-                        inlineEditable: true,
-                      },
-                      properties: {
-                        'fist-name': {
-                          type: 'string',
-                          'ui:metadata': {
-                            inlineEditable: true,
-                            quickOption: false,
-                          },
-                        },
-                        'last-name': {
-                          type: 'string',
-                          'ui:metadata': {
-                            inlineEditable: true,
-                            quickOption: false,
-                          },
-                        },
-                        'phone-number': {
-                          type: 'number',
-                          'ui:metadata': {
-                            inlineEditable: true,
-                            quickOption: false,
-                          },
-                        },
-                        email: {
-                          type: 'string',
-                          'ui:metadata': {
-                            inlineEditable: true,
-                            quickOption: false,
-                          },
-                        },
-                      },
-                    },
-                  },
-                  required: ['users-contact'],
-                },
-              },
-            ],
-          },
-          'v1',
-        );
-      },
-      SchemaValidationError,
-      'failed validation: Value `{"collapsedByDefault":true,"quickOption":false,"inlineEditable":true}` in `#/functions/0/input/properties/users-contact/ui:metadata` does not match any given oneof schema',
-    );
-  });
   it('should allow the autoReload field on the manifest', async () => {
     const manifest = await fetchTestManifest('validComponent.json');
 
@@ -443,7 +373,7 @@ describe('manifest/v1', () => {
         );
       },
       SchemaValidationError,
-      'failed validation: Value `{"inlineEditable":true,"quickOption":false,"collapsedByDefault":true}` in `#/functions/0/input/properties/users-contact/properties/fist-name/ui:metadata` does not match any given oneof schema',
+      'failed validation: ui:metadata property collapsedByDefault is only valid for object properties.',
     );
   });
 });