@travetto/schema 2.0.4 → 2.1.1

package/README.md

@@ -206,7 +206,7 @@ Validation Failed {
   "message": "Validation errors have occurred",
   "category": "data",
   "type": "ValidationResultError",
-  "at": "2021-03-14T05:00:00.618Z",
+  "at": "2022-03-14T04:00:00.618Z",
   "errors": [
     {
       "kind": "type",
@@ -435,7 +435,7 @@ Validation Failed {
   "message": "Validation errors have occurred",
   "category": "data",
   "type": "ValidationResultError",
-  "at": "2021-03-14T05:00:00.837Z",
+  "at": "2022-03-14T04:00:00.837Z",
   "errors": [
     {
       "kind": "type",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/schema",
   "displayName": "Schema",
-  "version": "2.0.4",
+  "version": "2.1.1",
   "description": "Data type registry for runtime validation, reflection and binding. ",
   "keywords": [
     "schema",
@@ -29,11 +29,11 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^2.0.2",
-    "@travetto/transformer": "^2.0.3"
+    "@travetto/registry": "^2.1.1",
+    "@travetto/transformer": "^2.1.1"
   },
   "optionalPeerDependencies": {
-    "@types/faker": "^5.5.6",
+    "@types/faker": "^5.5.9",
     "faker": "^5.5.3"
   },
   "publishConfig": {

package/src/bind-util.ts

@@ -149,6 +149,8 @@ export class BindUtil {
       return data as T;
     } else {
       const tgt = new (cls as ConcreteClass<T>)();
+      SchemaRegistry.ensureInstanceTypeField(cls, tgt);
+
       for (const [k, v] of Object.entries(tgt)) { // Do not retain undefined fields
         if (v === undefined) {
           delete tgt[k as keyof T];

package/src/decorator/schema.ts

@@ -36,4 +36,15 @@ export function View<T>(name: string, fields: ViewFieldsConfig<Partial<T>>) {
   return (target: Class<Partial<T>>) => {
     SchemaRegistry.registerPendingView(target, name, fields);
   };
+}
+
+/**
+ * Register a class as a subtype, with a specific discriminator
+ * @param name
+ * @returns
+ */
+export function SubType<T>(name: string) {
+  return (target: Class<Partial<T>>) => {
+    SchemaRegistry.registerSubTypes(target, name);
+  };
 }

package/src/service/registry.ts

@@ -24,6 +24,36 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     super(RootRegistry);
   }
 
+  #computeSubTypeName(cls: Class) {
+    if (!this.#typeKeys.has(cls)) {
+      this.#typeKeys.set(cls, cls.name
+        .replace(/([A-Z])([A-Z][a-z])/g, (all, l, r) => `${l}_${r.toLowerCase()}`)
+        .replace(/([a-z]|\b)([A-Z])/g, (all, l, r) => l ? `${l}_${r.toLowerCase()}` : r.toLowerCase())
+        .toLowerCase());
+    }
+    return this.#typeKeys.get(cls);
+  }
+
+  /**
+   * Get subtype name for a class
+   * @param cls Base class
+   */
+  getSubTypeName(cls: Class) {
+    if (this.get(cls).subType) {
+      return this.#computeSubTypeName(cls);
+    }
+  }
+
+  /**
+   * Ensure type is set properl
+   */
+  ensureInstanceTypeField<T>(cls: Class, o: T) {
+    const withType = (o as { type?: string });
+    if (this.get(cls)?.subType && 'type' in this.get(cls).views[AllViewⲐ].schema && !withType.type) {  // Do we have a type field defined
+      withType.type = this.#computeSubTypeName(cls); // Assign if missing
+    }
+  }
+
   /**
    * Find the subtype for a given instance
    * @param cls Class for instance
@@ -44,7 +74,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       if (type) {
         return this.#subTypes.get(cls)!.get(typeId) ?? cls;
       }
-    } else {
+    } else if (this.get(cls)?.subType) {
       const expectedType = this.#typeKeys.get(cls);
       if (expectedType && typeof type === 'string' && expectedType !== type) {
         throw new AppError(`Data of type ${type} does not match expected class type ${expectedType}`, 'data');
@@ -53,23 +83,19 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     return cls;
   }
 
-  /**
-   * Get subtype name for a class
-   * @param cls Base class
-   */
-  getSubTypeName(cls: Class) {
-    return cls.name
-      .replace(/([A-Z])([A-Z][a-z])/g, (all, l, r) => `${l}_${r.toLowerCase()}`)
-      .replace(/([a-z]|\b)([A-Z])/g, (all, l, r) => l ? `${l}_${r.toLowerCase()}` : r.toLowerCase())
-      .toLowerCase();
-  }
-
   /**
    * Register sub types for a class
    * @param cls The class to register against
    * @param type The subtype name
    */
-  registerSubTypes(cls: Class, type: string) {
+  registerSubTypes(cls: Class, type?: string) {
+    // Mark as subtype
+    (this.get(cls) ?? this.getOrCreatePending(cls)).subType = true;
+
+    type ??= this.#computeSubTypeName(cls)!;
+
+    this.#typeKeys.set(cls, type);
+
     let parent = this.getParentClass(cls)!;
     let parentConfig = this.get(parent);
 
@@ -77,12 +103,13 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       if (!this.#subTypes.has(parent)) {
         this.#subTypes.set(parent, new Map());
       }
-      this.#typeKeys.set(cls, type);
       this.#subTypes.get(parent)!.set(type, cls);
       this.#subTypes.get(parent)!.set(cls.ᚕid, cls);
       parent = this.getParentClass(parent!)!;
       parentConfig = this.get(parent);
     }
+
+    return type;
   }
 
   /**
@@ -109,6 +136,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     return {
       class: cls,
       validators: [],
+      subType: false,
       views: {
         [AllViewⲐ]: {
           schema: {},
@@ -259,6 +287,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       schema: { ...dest.views[AllViewⲐ].schema, ...src.views[AllViewⲐ].schema },
       fields: [...dest.views[AllViewⲐ].fields, ...src.views[AllViewⲐ].fields]
     };
+    dest.subType = src.subType || dest.subType;
     dest.title = src.title || dest.title;
     dest.validators = [...src.validators, ...dest.validators];
     return dest;
@@ -305,7 +334,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       }
     }
 
-    this.registerSubTypes(cls, this.getSubTypeName(cls));
+    this.registerSubTypes(cls);
 
     // Merge pending, back on top, to allow child to have higher precedence
     const pending = this.getOrCreatePending(cls);
@@ -332,10 +361,13 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     if (e.type === 'removing' && this.hasExpired(cls)) {
       // Recompute subtypes
       this.#subTypes.clear();
+      this.#typeKeys.delete(cls);
       this.#methodSchemas.delete(cls);
+
+      // Recompute subtype mappings
       for (const el of this.entries.keys()) {
         const clz = this.entries.get(el)!.class;
-        this.registerSubTypes(clz, this.getSubTypeName(clz));
+        this.registerSubTypes(clz);
       }
 
       SchemaChangeListener.clearSchemaDependency(cls);

package/src/service/types.ts

@@ -64,6 +64,10 @@ export interface ClassConfig extends DescribableConfig {
    * Global validators
    */
   validators: ValidatorFn<unknown, unknown>[];
+  /**
+   * Is the class a sub type
+   */
+  subType?: boolean;
 }
 
 /**

package/src/validate/validator.ts

@@ -225,7 +225,7 @@ export class SchemaValidator {
    * @param view The optional view to limit the scope to
    */
   static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
-    if (!Util.isPlainObject(o) && !(o instanceof cls)) {
+    if (!Util.isPlainObject(o) && !(o instanceof cls || cls.ᚕid === (o as ClassInstance<T>).constructor.ᚕid)) {
       throw new TypeMismatchError(cls.name, (o as unknown as ClassInstance).constructor.name);
     }
     cls = SchemaRegistry.resolveSubTypeForInstance(cls, o);

package/support/transform-util.ts

@@ -73,6 +73,7 @@ export class SchemaTransformUtil {
     const attrs: ts.PropertyAssignment[] = [];
 
     if (!ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
+      // eslint-disable-next-line no-bitwise
       if ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Readonly) > 0) {
         attrs.push(state.factory.createPropertyAssignment('mode', state.fromLiteral('readonly')));
       } else if (!node.questionToken && !typeExpr.undefinable && !node.initializer) {

package/support/transformer.schema.ts

@@ -3,8 +3,8 @@ import * as ts from 'typescript';
 import {
   TransformerState, OnProperty, OnClass, AfterClass, DecoratorMeta, DocUtil, DeclarationUtil, TransformerId, OnGetter, OnSetter
 } from '@travetto/transformer';
+
 import { SchemaTransformUtil } from './transform-util';
-import { access } from 'fs';
 
 const inSchema = Symbol.for('@trv:schema/schema');
 const accessors = Symbol.for('@trv:schema/schema');