@squiz/dx-json-schema-lib 1.21.1-alpha.4 → 1.21.1-alpha.40

package/src/JsonValidationService.ts

@@ -3,18 +3,20 @@ 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 { SchemaValidationError } from './errors/SchemaValidationError';
-import { Draft07, JSONError, JSONSchema, Draft, DraftConfig, isJSONError } from 'json-schema-library';
+import { Draft07, JSONError, JSONSchema, Draft, DraftConfig } from 'json-schema-library';
 
 import { draft07Config } from 'json-schema-library';
 import { MANIFEST_MODELS } from '.';
 import { customFormatValidators } from './validators/customFormatValidators';
-import { AnyPrimitiveType, AnyResolvableType, TypeResolver } from './jsonTypeResolution/arbitraryTypeResolution';
+import { AnyPrimitiveType, AnyResolvableType, TypeResolver } from './jsonTypeResolution/TypeResolver';
 import { JsonResolutionError } from './errors/JsonResolutionError';
 
 const defaultConfig: DraftConfig = {
@@ -123,6 +125,7 @@ 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);
 
@@ -143,6 +146,7 @@ export const ManifestV1MetaSchema: MetaSchemaInput = {
     '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,
   },
@@ -162,6 +166,8 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
       {
         ...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,
     );
@@ -169,15 +175,25 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
     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;
 
-    return this.typeResolver.getValidationSchemaForPrimitive(initialRef.type);
+    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);
   }
 
   /**
@@ -214,12 +230,10 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
         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 allPossibleSchemas: Array<JSONSchema> = schema.oneOfSchema.oneOf;
-        if (isJSONError(allPossibleSchemas)) return;
-
-        const primitiveSchema = allPossibleSchemas.find((schema): schema is P =>
-          this.typeResolver.isPrimitiveSchema(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);

package/src/index.ts

@@ -11,4 +11,11 @@ export * from './JsonValidationService';
 export * from './errors/SchemaValidationError';
 export * from './errors/JsonResolutionError';
 
-export * from './jsonTypeResolution';
+export * from './validators/utils/matrixAssetValidator';
+
+export * from './validators/utils/matrixAssetValidator';
+
+export * from './jsonTypeResolution/TypeResolver';
+export * from './jsonTypeResolution/TypeResolverBuilder';
+export * from './primitiveTypes';
+export * from './resolvableTypes';

package/src/jsonTypeResolution/{arbitraryTypeResolution.spec.ts → TypeResolver.spec.ts}

@@ -1,5 +1,5 @@
 import { JSONSchema } from 'json-schema-library';
-import { PrimitiveType, ResolvableType, TypeResolver } from './arbitraryTypeResolution';
+import { PrimitiveType, ResolvableType, TypeResolver } from './TypeResolver';
 
 const defaultSchema: JSONSchema = {
   type: 'object',
@@ -28,64 +28,33 @@ describe('getValidationSchemaForPrimitive', () => {
   it('should return only the primitive schema when no resolvers are defined', () => {
     const primitiveType = primitiveTypeFixture('MyPrimitive');
     const resolvableType = resolvableTypeFixture('MyResolvable');
-    const resolver = new TypeResolver(
-      {
-        MyPrimitive: primitiveType,
-      },
-      {
-        MyResolvable: resolvableType,
-      },
-      {},
-    );
+    const resolver = new TypeResolver([primitiveType], [resolvableType], {});
 
-    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual({
-      oneOf: [primitiveType],
-    });
+    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType]);
   });
 
   it('should return the primitive schema and the resolvable schema when a resolver is defined', () => {
     const primitiveType = primitiveTypeFixture('MyPrimitive');
     const resolvableType = resolvableTypeFixture('MyResolvable');
-    const resolver = new TypeResolver(
-      {
-        MyPrimitive: primitiveType,
-      },
-      {
-        MyResolvable: resolvableType,
+    const resolver = new TypeResolver([primitiveType], [resolvableType], {
+      MyPrimitive: {
+        MyResolvable: () => null,
       },
-      {
-        MyPrimitive: {
-          MyResolvable: () => null,
-        },
-      },
-    );
-
-    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual({
-      oneOf: [primitiveType, resolvableType],
     });
+
+    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType, resolvableType]);
   });
 
   it('should return the primitive schema and the resolvable schema when a resolver is defined for a different primitive', () => {
     const primitiveType = primitiveTypeFixture('MyPrimitive');
     const resolvableType = resolvableTypeFixture('MyResolvable');
-    const resolver = new TypeResolver(
-      {
-        MyPrimitive: primitiveType,
-        MyOtherPrimitive: primitiveTypeFixture('MyOtherPrimitive'),
-      },
-      {
-        MyResolvable: resolvableType,
+    const resolver = new TypeResolver([primitiveType, primitiveTypeFixture('MyOtherPrimitive')], [resolvableType], {
+      MyOtherPrimitive: {
+        MyResolvable: () => null,
       },
-      {
-        MyOtherPrimitive: {
-          MyResolvable: () => null,
-        },
-      },
-    );
-
-    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual({
-      oneOf: [primitiveType],
     });
+
+    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType]);
   });
 
   it('should error when resolver map contains a key not listed in resolver schemas', () => {
@@ -93,20 +62,12 @@ describe('getValidationSchemaForPrimitive', () => {
     const resolvableType = resolvableTypeFixture('MyResolvable');
     expect(
       () =>
-        new TypeResolver<typeof primitiveType, typeof resolvableType>(
-          {
-            MyPrimitive: primitiveType,
-          },
-          {
-            MyResolvable: resolvableType,
+        new TypeResolver<typeof primitiveType, typeof resolvableType>([primitiveType], [resolvableType], {
+          MyPrimitive: {
+            // @ts-expect-error - this is not a valid resolvable type
+            MyOtherResolvable: () => null,
           },
-          {
-            MyPrimitive: {
-              // @ts-expect-error - this is not a valid resolvable type
-              MyOtherResolvable: () => null,
-            },
-          },
-        ),
+        }),
     ).toThrowError();
   });
 
@@ -115,20 +76,12 @@ describe('getValidationSchemaForPrimitive', () => {
     const resolvableType = resolvableTypeFixture('MyResolvable');
     expect(
       () =>
-        new TypeResolver<typeof primitiveType, typeof resolvableType>(
-          {
-            MyPrimitive: primitiveType,
-          },
-          {
-            MyResolvable: resolvableType,
-          },
-          {
-            // @ts-expect-error - this is not a valid primitive type
-            MyOtherPrimitive: {
-              MyResolvable: () => null,
-            },
+        new TypeResolver<typeof primitiveType, typeof resolvableType>([primitiveType], [resolvableType], {
+          // @ts-expect-error - this is not a valid primitive type
+          MyOtherPrimitive: {
+            MyResolvable: () => null,
           },
-        ),
+        }),
     ).toThrowError();
   });
 });

package/src/jsonTypeResolution/{arbitraryTypeResolution.ts → TypeResolver.ts}

@@ -35,7 +35,7 @@ export function ResolvableType<SHAPE, TITLE extends string>(
 }
 export type AnyResolvableType = ResolvableType<string, any>;
 
-type Resolver<INPUT, OUTPUT> = (input: INPUT) => MaybePromise<OUTPUT>;
+export type Resolver<INPUT, OUTPUT> = (input: INPUT) => MaybePromise<OUTPUT>;
 
 /**
  * A JSON Type Resolver class which stores the primitive and resolvable JSON Schema types and their resolvers
@@ -43,27 +43,35 @@ type Resolver<INPUT, OUTPUT> = (input: INPUT) => MaybePromise<OUTPUT>;
  * No serious logic is required here. The class should only provide data access methods and type safety
  */
 export class TypeResolver<P extends AnyPrimitiveType, R extends AnyResolvableType> {
+  private primitives: Map<P['title'], P>;
+  private resolvables: Map<R['title'], R>;
   constructor(
-    private primitives: { [K in P as P['title']]: K },
-    private resolvables: { [K in R as R['title']]: K },
+    primitives: P[],
+    resolvables: R[] = [],
     public resolvers: {
       [PT in P as PT['title']]?: {
         [RT in R as RT['title']]?: Resolver<RT['__shape__'], PT['__shape__']>;
       };
-    },
+    } = {},
   ) {
+    this.primitives = new Map(primitives.map((p) => [p.title, p]));
+    this.resolvables = new Map(resolvables.map((r) => [r.title, r]));
     for (const [primitiveKey, primitiveResolvers] of Object.entries(resolvers) as [string, Record<string, any>][]) {
-      if (!(primitiveKey in primitives)) {
+      if (!this.primitives.has(primitiveKey)) {
         throw new Error('Resolver keys must match a primitive schema');
       }
-      if (!Object.keys(primitiveResolvers).every((k) => k in resolvables)) {
+      if (!Object.keys(primitiveResolvers).every((k) => this.resolvables.has(k))) {
         throw new Error('Primitive resolvers keys must match a resolvable schema');
       }
     }
   }
 
+  get validationSchemaDefinitions() {
+    return [...this.primitives.values(), ...this.resolvables.values()];
+  }
+
   isPrimitiveType(type: string): type is P['title'] {
-    return type in this.primitives;
+    return this.primitives.has(type);
   }
 
   isPrimitiveSchema(schema: JSONSchema): schema is P {
@@ -71,30 +79,26 @@ export class TypeResolver<P extends AnyPrimitiveType, R extends AnyResolvableTyp
   }
 
   isResolvableSchema(schema: JSONSchema): schema is R {
-    return schema.title in this.resolvables;
+    return this.resolvables.has(schema.title);
   }
 
-  getValidationSchemaForPrimitive(type: keyof typeof this.primitives) {
-    const primitiveSchema = this.primitives[type];
-    const validSchemas = [primitiveSchema, ...this.fetchResolvableSchemasForPrimitive(type)];
-
-    return {
-      oneOf: validSchemas,
-    };
+  getValidationSchemaForPrimitive(type: P['title']) {
+    const primitiveSchema = this.primitives.get(type) as JsonResolutionSchema<string>;
+    return [primitiveSchema, ...this.fetchResolvableSchemasForPrimitive(type)];
   }
 
-  private *fetchResolvableSchemasForPrimitive(type: keyof typeof this.primitives) {
+  private *fetchResolvableSchemasForPrimitive(type: P['title']) {
     for (const resolverKey in this.resolvers[type]) {
-      yield this.resolvables[resolverKey];
+      yield this.resolvables.get(resolverKey) as JsonResolutionSchema<string>;
     }
   }
 
-  tryGetResolver<PS extends P, RS extends R>(
-    primitiveSchema: PS,
-    resolvableSchema: RS,
-  ): Resolver<RS['__shape__'], PS['__shape__']> | undefined {
-    if (!(primitiveSchema.title in this.resolvers)) return;
+  tryGetResolver(
+    primitiveSchemaTitle: string,
+    resolvableSchema: R,
+  ): Resolver<R['__shape__'], P['__shape__']> | undefined {
+    if (!(primitiveSchemaTitle in this.resolvers)) return;
     // Sometimes typescript can be insanely annoying
-    return (this.resolvers[primitiveSchema.title as keyof typeof this.resolvers] as any)?.[resolvableSchema.title];
+    return (this.resolvers[primitiveSchemaTitle as keyof typeof this.resolvers] as any)?.[resolvableSchema.title];
   }
 }

package/src/jsonTypeResolution/TypeResolverBuilder.ts

@@ -0,0 +1,43 @@
+import { AnyPrimitiveType, AnyResolvableType, Resolver, TypeResolver } from './TypeResolver';
+
+type TypeResolverFunction<P extends AnyPrimitiveType, R extends AnyResolvableType> = Resolver<
+  R['__shape__'],
+  P['__shape__']
+>;
+
+export class TypeResolverBuilder {
+  private primitives = new Set<AnyPrimitiveType>();
+  private resolvables = new Set<AnyResolvableType>();
+  private resolverMap: Record<string, Record<string, TypeResolverFunction<AnyPrimitiveType, AnyResolvableType>>> = {};
+  static new() {
+    return new TypeResolverBuilder();
+  }
+
+  addPrimitive<P extends AnyPrimitiveType>(primitive: P) {
+    this.primitives.add(primitive);
+    return this;
+  }
+
+  addResolver<P extends AnyPrimitiveType, R extends AnyResolvableType>(
+    primitive: P,
+    resolvable: R,
+    resolver: TypeResolverFunction<P, R>,
+  ) {
+    this.primitives.add(primitive);
+    this.resolvables.add(resolvable);
+    this.resolverMap[primitive.title] ??= {};
+    this.resolverMap[primitive.title][resolvable.title] = resolver as TypeResolverFunction<
+      AnyPrimitiveType,
+      AnyResolvableType
+    >;
+    return this;
+  }
+
+  build() {
+    return new TypeResolver(
+      Array.from(this.primitives.values()),
+      Array.from(this.resolvables.values()),
+      this.resolverMap,
+    );
+  }
+}

package/src/manifest/v1/DxContentMetaSchema.json

@@ -16,7 +16,7 @@
       "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }]
     },
     "simpleTypes": {
-      "enum": ["array", "boolean", "integer", "null", "number", "object", "string", "FormattedText"]
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string", "FormattedText", "SquizImage"]
     },
     "stringArray": {
       "type": "array",