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

package/src/JsonSchemaService.ts

@@ -0,0 +1,159 @@
+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 JobV1 from './manifest/v1/JobV1.json';
+import v1 from './manifest/v1/v1.json';
+import { JSONSchema, Draft } from '@squiz/json-schema-library';
+
+import { draft07Config } from '@squiz/json-schema-library';
+import { AnyPrimitiveType, AnyResolvableType, ResolverContext, TypeResolver } from './jsonTypeResolution/TypeResolver';
+import { JsonResolutionError } from './errors/JsonResolutionError';
+import { processValidationResult } from './processValidationResult';
+import { defaultConfig } from '.';
+
+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,
+  },
+};
+
+export const JobV1MetaSchema: MetaSchemaInput = {
+  root: JobV1,
+  remotes: {
+    'DxComponentInputSchema.json/DxContentMetaSchema.json': DxContentMetaSchema,
+    '/DxComponentInputSchema.json': DxComponentInputSchema,
+    '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.
+ */
+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, ctx: ResolverContext = {}) {
+    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, ctx))
+          .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;
+  }
+}