@travetto/schema 7.0.0-rc.0 → 7.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "7.0.0-rc.0",
+  "version": "7.0.0-rc.1",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",
@@ -27,10 +27,10 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^7.0.0-rc.0"
+    "@travetto/registry": "^7.0.0-rc.1"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.0"
+    "@travetto/transformer": "^7.0.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/bind-util.ts

@@ -133,22 +133,22 @@ export class BindUtil {
 
   /**
    * Bind data to the schema for a class, with an optional view
-   * @param cons The schema class to bind against
+   * @param cls The schema class to bind against
    * @param data The provided data to bind
    * @param cfg The bind configuration
    */
-  static bindSchema<T>(cons: Class<T>, data?: undefined, cfg?: BindConfig): undefined;
-  static bindSchema<T>(cons: Class<T>, data?: null, cfg?: BindConfig): null;
-  static bindSchema<T>(cons: Class<T>, data?: object | T, cfg?: BindConfig): T;
-  static bindSchema<T>(cons: Class<T>, data?: object | T, cfg?: BindConfig): T | null | undefined {
+  static bindSchema<T>(cls: Class<T>, data?: undefined, cfg?: BindConfig): undefined;
+  static bindSchema<T>(cls: Class<T>, data?: null, cfg?: BindConfig): null;
+  static bindSchema<T>(cls: Class<T>, data?: object | T, cfg?: BindConfig): T;
+  static bindSchema<T>(cls: Class<T>, data?: object | T, cfg?: BindConfig): T | null | undefined {
     if (data === null || data === undefined) {
       return data;
     }
-    if (data instanceof cons) {
+    if (data instanceof cls) {
       return castTo(data);
     } else {
-      const cls = SchemaRegistryIndex.resolveInstanceType<T>(cons, asFull<T>(data));
-      const instance = classConstruct<T & { type?: string }>(cls);
+      const resolvedCls = SchemaRegistryIndex.resolveInstanceType<T>(cls, asFull<T>(data));
+      const instance = classConstruct<T & { type?: string }>(resolvedCls);
 
       for (const k of TypedObject.keys(instance)) { // Do not retain undefined fields
         if (instance[k] === undefined) {
@@ -156,25 +156,25 @@ export class BindUtil {
         }
       }
 
-      const out = this.bindSchemaToObject(cls, instance, data, cfg);
-      SchemaRegistryIndex.get(cls).ensureInstanceTypeField(out);
+      const out = this.bindSchemaToObject(resolvedCls, instance, data, cfg);
+      SchemaRegistryIndex.get(resolvedCls).ensureInstanceTypeField(out);
       return out;
     }
   }
 
   /**
    * Bind the schema to the object
-   * @param cons The schema class
-   * @param obj The target object (instance of cons)
+   * @param cls The schema class
+   * @param obj The target object (instance of cls)
    * @param data The data to bind
    * @param cfg The bind configuration
    */
-  static bindSchemaToObject<T>(cons: Class<T>, obj: T, data?: object, cfg: BindConfig = {}): T {
+  static bindSchemaToObject<T>(cls: Class<T>, obj: T, data?: object, cfg: BindConfig = {}): T {
     const view = cfg.view; // Does not convey
     delete cfg.view;
 
     if (!!data && isInstance<T>(data)) {
-      const adapter = SchemaRegistryIndex.get(cons);
+      const adapter = SchemaRegistryIndex.get(cls);
       const conf = adapter.get();
 
       // If no configuration
@@ -185,7 +185,7 @@ export class BindUtil {
       } else {
         let schema: SchemaFieldMap = conf.fields;
         if (view) {
-          schema = adapter.getSchema(view);
+          schema = adapter.getFields(view);
           if (!schema) {
             throw new Error(`View not found: ${view.toString()}`);
           }
@@ -312,7 +312,7 @@ export class BindUtil {
    * @returns
    */
   static coerceMethodParams<T>(cls: Class<T>, method: string | symbol, params: unknown[], applyDefaults = true): unknown[] {
-    const paramConfigs = SchemaRegistryIndex.getMethodConfig(cls, method).parameters;
+    const paramConfigs = SchemaRegistryIndex.get(cls).getMethod(method).parameters;
     return this.coerceParameters(paramConfigs, params, applyDefaults);
   }
 }

package/src/service/registry-adapter.ts

@@ -92,7 +92,7 @@ function combineClassWithParent<T extends SchemaClassConfig>(base: T, parent: T)
     case 'Required':
     case 'Partial': {
       base.fields = Object.fromEntries(
-        Object.entries(base.fields).map(([k, v]) => [k, {
+        Object.entries(parent.fields).map(([k, v]) => [k, {
           ...v,
           required: {
             active: base.mappedOperation === 'Required'
@@ -294,7 +294,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     return this.getMethod(method).returnType!.type;
   }
 
-  getSchema(view?: string): SchemaFieldMap {
+  getFields(view?: string): SchemaFieldMap {
     if (!view) {
       return this.#config.fields;
     }

package/src/service/registry-index.ts

@@ -1,7 +1,7 @@
 import { ChangeEvent, RegistrationMethods, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 import { AppError, castKey, castTo, Class, classConstruct, getParentClass, Util } from '@travetto/runtime';
 
-import { SchemaFieldConfig, SchemaClassConfig, SchemaFieldMap, SchemaMethodConfig } from './types.ts';
+import { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
 import { SchemaRegistryAdapter } from './registry-adapter.ts';
 import { SchemaChangeListener } from './changes.ts';
 
@@ -24,14 +24,6 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.store.get(cls).getDiscriminatedConfig();
   }
 
-  static getFieldMap(cls: Class, view?: string): SchemaFieldMap {
-    return this.#instance.store.get(cls).getSchema(view);
-  }
-
-  static getMethodConfig(cls: Class, method: string | symbol): SchemaMethodConfig {
-    return this.#instance.store.get(cls).getMethod(method);
-  }
-
   static has(cls: Class): boolean {
     return this.#instance.store.has(cls);
   }
@@ -64,8 +56,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.store.get(cls);
   }
 
-  static getOptionalConfig(cls: Class): SchemaClassConfig | undefined {
-    return this.#instance.store.getOptional(cls)?.get();
+  static getOptional(cls: Class): Omit<SchemaRegistryAdapter, RegistrationMethods> | undefined {
+    return this.#instance.store.getOptional(cls);
   }
 
   static getClasses(): Class[] {
@@ -160,14 +152,12 @@ export class SchemaRegistryIndex implements RegistryIndex {
    * @param cls Class for instance
    * @param o Actual instance
    */
-  resolveInstanceType<T>(requestedCls: Class<T>, o: T): Class {
-    const cls = this.store.getClassById(requestedCls.Ⲑid); // Resolve by id to handle any stale references
-    const adapter = this.store.get(cls);
-    const { discriminatedField, discriminatedType } = adapter.get();
+  resolveInstanceType<T>(cls: Class<T>, o: T): Class {
+    const { discriminatedField, discriminatedType, class: targetClass } = this.store.get(cls).get();
     if (!discriminatedField) {
-      return cls;
+      return targetClass;
     } else {
-      const base = this.getBaseClass(cls);
+      const base = this.getBaseClass(targetClass);
       const map = this.#byDiscriminatedTypes.get(base);
       const type = castTo<string>(o[castKey<T>(discriminatedField)]) ?? discriminatedType;
       if (!type) {
@@ -177,8 +167,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
         throw new AppError(`Unable to resolve discriminated type '${type}' for class ${base.name}`);
       }
       const requested = map.get(type)!;
-      if (!(classConstruct(requested) instanceof requestedCls)) {
-        throw new AppError(`Resolved discriminated type '${type}' for class ${base.name} is not an instance of requested type ${requestedCls.name}`);
+      if (!(classConstruct(requested) instanceof targetClass)) {
+        throw new AppError(`Resolved discriminated type '${type}' for class ${base.name} is not an instance of requested type ${targetClass.name}`);
       }
       return requested;
     }

package/src/validate/validator.ts

@@ -15,7 +15,7 @@ import { SchemaRegistryIndex } from '../service/registry-index.ts';
  */
 function resolveFieldMap<T>(base: Class<T>, o: T): SchemaFieldMap {
   const target = SchemaRegistryIndex.resolveInstanceType(base, o);
-  return SchemaRegistryIndex.getFieldMap(target);
+  return SchemaRegistryIndex.get(target).getFields();
 }
 
 function isClassInstance<T>(o: unknown): o is ClassInstance<T> {
@@ -257,7 +257,7 @@ export class SchemaValidator {
     }
     cls = SchemaRegistryIndex.resolveInstanceType(cls, o);
 
-    const fields = SchemaRegistryIndex.getFieldMap(cls, view);
+    const fields = SchemaRegistryIndex.get(cls).getFields(view);
 
     // Validate using standard behaviors
     const errors = [
@@ -313,7 +313,7 @@ export class SchemaValidator {
    */
   static async validateMethod<T>(cls: Class<T>, method: string | symbol, params: unknown[], prefixes: (string | symbol | undefined)[] = []): Promise<void> {
     const errors: ValidationError[] = [];
-    const config = SchemaRegistryIndex.getMethodConfig(cls, method);
+    const config = SchemaRegistryIndex.get(cls).getMethod(method);
 
     for (const param of config.parameters) {
       const i = param.index;