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

package/src/decorator/common.ts

@@ -10,14 +10,14 @@ import { SchemaRegistryIndex } from '../service/registry-index.ts';
  * @kind decorator
  */
 export function Describe(config: Partial<Omit<SchemaCoreConfig, 'metadata'>>) {
-  return (instanceOrCls: Class | ClassInstance, property?: string | symbol, descOrIdx?: PropertyDescriptor | number): void => {
+  return (instanceOrCls: Class | ClassInstance, property?: string, descriptorOrIdx?: PropertyDescriptor | number): void => {
     const adapter = SchemaRegistryIndex.getForRegister(getClass(instanceOrCls));
     if (!property) {
       adapter.register(config);
     } else {
-      if (descOrIdx !== undefined && typeof descOrIdx === 'number') {
-        adapter.registerParameter(property, descOrIdx, config);
-      } else if (typeof descOrIdx === 'object' && typeof descOrIdx.value === 'function') {
+      if (descriptorOrIdx !== undefined && typeof descriptorOrIdx === 'number') {
+        adapter.registerParameter(property, descriptorOrIdx, config);
+      } else if (typeof descriptorOrIdx === 'object' && typeof descriptorOrIdx.value === 'function') {
         adapter.registerMethod(property, config);
       } else {
         adapter.registerField(property, config);
@@ -31,7 +31,7 @@ export function Describe(config: Partial<Omit<SchemaCoreConfig, 'metadata'>>) {
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export const IsPrivate = (): (instanceOrCls: Class | ClassInstance, property?: string | symbol) => void => Describe({ private: true });
+export const IsPrivate = (): (instanceOrCls: Class | ClassInstance, property?: string) => void => Describe({ private: true });
 
 /**
  * Mark a field/method as ignored

package/src/decorator/field.ts

@@ -3,23 +3,25 @@ import { Any, ClassInstance, getClass } from '@travetto/runtime';
 import { SchemaFieldConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
-type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void);
+type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(
+  instance: T, property: K, idx?: TypedPropertyDescriptor<Any> | number
+) => void);
 
-function field<V>(...obj: Partial<SchemaFieldConfig>[]): PropType<V> {
-  return (instance: ClassInstance, property: string | symbol): void => {
-    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, ...obj);
+function field<V>(...configs: Partial<SchemaFieldConfig>[]): PropType<V> {
+  return (instance: ClassInstance, property: string): void => {
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, ...configs);
   };
 }
 
 /**
  * Registering a field
  * @param type The type for the field
- * @param config The field configuration
+ * @param configs The field configuration
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Field(type: Pick<SchemaFieldConfig, 'type' | 'array'>, ...config: Partial<SchemaFieldConfig>[]): PropType<unknown> {
-  return field(type, ...config);
+export function Field(type: Pick<SchemaFieldConfig, 'type' | 'array'>, ...configs: Partial<SchemaFieldConfig>[]): PropType<unknown> {
+  return field(type, ...configs);
 }
 
 /**

package/src/decorator/input.ts

@@ -4,16 +4,18 @@ import { CommonRegExp } from '../validate/regexp.ts';
 import { CONSTRUCTOR_PROPERTY, SchemaInputConfig } from '../service/types.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
-type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(t: T, k: K, idx?: TypedPropertyDescriptor<Any> | number) => void);
+type PropType<V> = (<T extends Partial<Record<K, V | Function>>, K extends string>(
+  instance: T, property: K, idx?: TypedPropertyDescriptor<Any> | number
+) => void);
 
-function input<V>(...obj: Partial<SchemaInputConfig>[]): PropType<V> {
-  return (instanceOrCls: ClassInstance | Class, property: string | symbol, idx?: number | TypedPropertyDescriptor<Any>): void => {
+function input<V>(...configs: Partial<SchemaInputConfig>[]): PropType<V> {
+  return (instanceOrCls: ClassInstance | Class, property: string, idx?: number | TypedPropertyDescriptor<Any>): void => {
     const adapter = SchemaRegistryIndex.getForRegister(getClass(instanceOrCls));
     const propertyKey = property ?? CONSTRUCTOR_PROPERTY;
     if (typeof idx === 'number') {
-      adapter.registerParameter(propertyKey, idx, ...obj);
+      adapter.registerParameter(propertyKey, idx, ...configs);
     } else {
-      adapter.registerField(propertyKey, ...obj);
+      adapter.registerField(propertyKey, ...configs);
     }
   };
 }
@@ -21,12 +23,12 @@ function input<V>(...obj: Partial<SchemaInputConfig>[]): PropType<V> {
 /**
  * Registering an input
  * @param type The type for the input
- * @param config The input configuration
+ * @param configs The input configuration
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Input(type: Pick<SchemaInputConfig, 'type' | 'array'>, ...config: Partial<SchemaInputConfig>[]): PropType<unknown> {
-  return input(type, ...config);
+export function Input(type: Pick<SchemaInputConfig, 'type' | 'array'>, ...configs: Partial<SchemaInputConfig>[]): PropType<unknown> {
+  return input(type, ...configs);
 }
 
 /**
@@ -197,7 +199,7 @@ export function Specifier(...specifiers: string[]): PropType<unknown> { return i
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function DiscriminatorField(): ((t: ClassInstance, k: string) => void) {
+export function DiscriminatorField(): ((instance: ClassInstance, property: string) => void) {
   return (instance: ClassInstance, property: string): void => {
     SchemaRegistryIndex.getForRegister(getClass(instance)).register({
       discriminatedBase: true,

package/src/decorator/method.ts

@@ -4,6 +4,8 @@ import { SchemaMethodConfig } from '../service/types';
 import { SchemaRegistryIndex } from '../service/registry-index';
 import { MethodValidatorFn } from '../validate/types';
 
+type MethodDecorator = (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor | void;
+
 /**
  * Registering a method
  * @param config The method configuration
@@ -11,7 +13,7 @@ import { MethodValidatorFn } from '../validate/types';
  * @kind decorator
  */
 export function Method(...config: Partial<SchemaMethodConfig>[]) {
-  return (instanceOrCls: ClassInstance, property: string | symbol): void => {
+  return (instanceOrCls: ClassInstance, property: string): void => {
     SchemaRegistryIndex.getForRegister(getClass(instanceOrCls)).registerMethod(property, ...config);
   };
 }

package/src/decorator/schema.ts

@@ -16,12 +16,12 @@ type ValidStringField<T> = { [K in Extract<keyof T, string>]: T[K] extends strin
  * @augments `@travetto/schema:Schema`
  * @kind decorator
  */
-export function Schema(cfg?: Partial<Pick<SchemaClassConfig, 'validators' | 'methods'>>) {
+export function Schema(config?: Partial<Pick<SchemaClassConfig, 'validators' | 'methods'>>) {
   return <T, U extends Class<T>>(cls: U): void => {
     cls.from ??= function <V>(this: Class<V>, data: DeepPartial<V>, view?: string): V {
       return BindUtil.bindSchema(this, data, { view });
     };
-    SchemaRegistryIndex.getForRegister(cls).registerClass(cfg);
+    SchemaRegistryIndex.getForRegister(cls).registerClass(config);
   };
 }
 

package/src/internal/types.ts

@@ -5,7 +5,7 @@ const InvalidSymbol = Symbol();
 /**
  * Point Implementation
  */
-export class PointImpl {
+export class PointImplementation {
 
   /**
    * Validate we have an actual point
@@ -20,7 +20,7 @@ export class PointImpl {
    */
   static bindSchema(input: unknown): [number, number] | typeof InvalidSymbol | undefined {
     if (Array.isArray(input) && input.length === 2) {
-      const [a, b] = input.map(x => DataUtil.coerceType(x, Number, false));
+      const [a, b] = input.map(value => DataUtil.coerceType(value, Number, false));
       return [a, b];
     } else {
       return InvalidSymbol;
@@ -28,4 +28,4 @@ export class PointImpl {
   }
 }
 
-Object.defineProperty(PointImpl, 'name', { value: 'Point' });
+Object.defineProperty(PointImplementation, 'name', { value: 'Point' });

package/src/name.ts

@@ -1,6 +1,6 @@
 import { SchemaClassConfig } from './service/types.ts';
 
-const ID_RE = /(\d{1,100})Δ$/;
+const ID_REGEX = /(\d{1,100})Δ$/;
 
 /**
  * Name resolver, specifically for synthetic types
@@ -17,9 +17,9 @@ export class SchemaNameResolver {
   getName(schema: SchemaClassConfig): string {
     const cls = schema.class;
     const id = cls.Ⲑid;
-    if (ID_RE.test(cls.name)) {
+    if (ID_REGEX.test(cls.name)) {
       if (!this.#schemaIdToName.has(id)) {
-        const name = cls.name.replace(ID_RE, (_, uid) => uid.slice(-this.#digits));
+        const name = cls.name.replace(ID_REGEX, (_, uniqueId) => uniqueId.slice(-this.#digits));
         this.#schemaIdToName.set(id, name);
       }
       return this.#schemaIdToName.get(id)!;

package/src/service/changes.ts

@@ -40,17 +40,17 @@ class $SchemaChangeListener {
 
   /**
    * On schema change, emit the change event for the whole schema
-   * @param cb The function to call on schema change
+   * @param handler The function to call on schema change
    */
-  onSchemaChange(handler: (e: SchemaChangeEvent) => void): void {
+  onSchemaChange(handler: (event: SchemaChangeEvent) => void): void {
     this.#emitter.on('schema', handler);
   }
 
   /**
    * On schema field change, emit the change event for the whole schema
-   * @param cb The function to call on schema field change
+   * @param handler The function to call on schema field change
    */
-  onFieldChange(handler: (e: FieldChangeEvent) => void): void {
+  onFieldChange(handler: (event: FieldChangeEvent) => void): void {
     this.#emitter.on('field', handler);
   }
 
@@ -63,13 +63,13 @@ class $SchemaChangeListener {
 
   /**
    * Track a specific class for dependencies
-   * @param src The target class
+   * @param cls The target class
    * @param parent The parent class
    * @param path The path within the object hierarchy to arrive at the class
    * @param config The configuration or the class
    */
-  trackSchemaDependency(src: Class, parent: Class, path: SchemaFieldConfig[], config: SchemaClassConfig): void {
-    const idValue = src.Ⲑid;
+  trackSchemaDependency(cls: Class, parent: Class, path: SchemaFieldConfig[], config: SchemaClassConfig): void {
+    const idValue = cls.Ⲑid;
     if (!this.#mapping.has(idValue)) {
       this.#mapping.set(idValue, new Map());
     }
@@ -86,13 +86,13 @@ class $SchemaChangeListener {
     const clsId = cls.Ⲑid;
 
     if (this.#mapping.has(clsId)) {
-      const deps = this.#mapping.get(clsId)!;
-      for (const depClsId of deps.keys()) {
-        if (!updates.has(depClsId)) {
-          updates.set(depClsId, { config: deps.get(depClsId)!.config, subs: [] });
+      const dependencies = this.#mapping.get(clsId)!;
+      for (const dependencyClsId of dependencies.keys()) {
+        if (!updates.has(dependencyClsId)) {
+          updates.set(dependencyClsId, { config: dependencies.get(dependencyClsId)!.config, subs: [] });
         }
-        const c = deps.get(depClsId)!;
-        updates.get(depClsId)!.subs.push({ path: [...c.path], fields: changes });
+        const childDependency = dependencies.get(dependencyClsId)!;
+        updates.get(dependencyClsId)!.subs.push({ path: [...childDependency.path], fields: changes });
       }
     }
 
@@ -103,49 +103,49 @@ class $SchemaChangeListener {
 
   /**
    * Emit field level changes in the schema
-   * @param prev The previous class config
-   * @param curr The current class config
+   * @param previous The previous class config
+   * @param current The current class config
    */
-  emitFieldChanges(ev: ChangeEvent<SchemaClassConfig>): void {
-    const prev = 'prev' in ev ? ev.prev : undefined;
-    const curr = 'curr' in ev ? ev.curr : undefined;
+  emitFieldChanges(event: ChangeEvent<SchemaClassConfig>): void {
+    const previous = 'previous' in event ? event.previous : undefined;
+    const current = 'current' in event ? event.current : undefined;
 
-    const prevFields = new Set(Object.keys(prev?.fields ?? {}));
-    const currFields = new Set(Object.keys(curr?.fields ?? {}));
+    const previousFields = new Set(Object.keys(previous?.fields ?? {}));
+    const currentFields = new Set(Object.keys(current?.fields ?? {}));
 
     const changes: ChangeEvent<SchemaFieldConfig>[] = [];
 
-    for (const c of currFields) {
-      if (!prevFields.has(c) && curr) {
-        changes.push({ curr: curr.fields[c], type: 'added' });
+    for (const field of currentFields) {
+      if (!previousFields.has(field) && current) {
+        changes.push({ current: current.fields[field], type: 'added' });
       }
     }
 
-    for (const c of prevFields) {
-      if (!currFields.has(c) && prev) {
-        changes.push({ prev: prev.fields[c], type: 'removing' });
+    for (const field of previousFields) {
+      if (!currentFields.has(field) && previous) {
+        changes.push({ previous: previous.fields[field], type: 'removing' });
       }
     }
 
     // Handle class references changing, but keeping same id
     const compareTypes = (a: Class, b: Class): boolean => a.Ⲑid ? a.Ⲑid === b.Ⲑid : a === b;
 
-    for (const c of currFields) {
-      if (prevFields.has(c) && prev && curr) {
-        const prevSchema = prev.fields[c];
-        const currSchema = curr.fields[c];
+    for (const field of currentFields) {
+      if (previousFields.has(field) && previous && current) {
+        const prevSchema = previous.fields[field];
+        const currSchema = current.fields[field];
         if (
           JSON.stringify(prevSchema) !== JSON.stringify(currSchema) ||
           !compareTypes(prevSchema.type, currSchema.type)
         ) {
-          changes.push({ prev: prev.fields[c], curr: curr.fields[c], type: 'changed' });
+          changes.push({ previous: previous.fields[field], current: current.fields[field], type: 'changed' });
         }
       }
     }
 
     // Send field changes
-    this.#emitter.emit('field', { cls: curr!.class, changes });
-    this.emitSchemaChanges({ cls: curr!.class, changes });
+    this.#emitter.emit('field', { cls: current!.class, changes });
+    this.emitSchemaChanges({ cls: current!.class, changes });
   }
 }
 

package/src/service/registry-adapter.ts

@@ -8,13 +8,13 @@ import {
 } from './types';
 
 const classToDiscriminatedType = (cls: Class): string => 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())
+  .replace(/([A-Z])([A-Z][a-z])/g, (all, left, right) => `${left}_${right.toLowerCase()}`)
+  .replace(/([a-z]|\b)([A-Z])/g, (all, left, right) => left ? `${left}_${right.toLowerCase()}` : right.toLowerCase())
   .toLowerCase();
 
 function assignMetadata<T>(key: symbol, base: SchemaCoreConfig, data: Partial<T>[]): T {
-  const md = base.metadata ??= {};
-  const out = md[key] ??= {};
+  const metadata = base.metadata ??= {};
+  const out = metadata[key] ??= {};
   for (const d of data) {
     safeAssign(out, d);
   }
@@ -92,8 +92,8 @@ function combineClassWithParent<T extends SchemaClassConfig>(base: T, parent: T)
     case 'Required':
     case 'Partial': {
       base.fields = Object.fromEntries(
-        Object.entries(parent.fields).map(([k, v]) => [k, {
-          ...v,
+        Object.entries(parent.fields).map(([key, value]) => [key, {
+          ...value,
           required: {
             active: base.mappedOperation === 'Required'
           }
@@ -105,8 +105,8 @@ function combineClassWithParent<T extends SchemaClassConfig>(base: T, parent: T)
     case 'Omit': {
       const keys = new Set<string>(base.mappedFields ?? []);
       base.fields = Object.fromEntries(
-        Object.entries(parent.fields).filter(([k]) =>
-          base.mappedOperation === 'Pick' ? keys.has(k) : !keys.has(k)
+        Object.entries(parent.fields).filter(([key]) =>
+          base.mappedOperation === 'Pick' ? keys.has(key) : !keys.has(key)
         )
       );
       break;
@@ -145,7 +145,7 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   }
 
   register(...data: Partial<SchemaClassConfig>[]): SchemaClassConfig {
-    const cfg = this.#config ??= {
+    const config = this.#config ??= {
       methods: {},
       class: this.#cls,
       views: {},
@@ -153,38 +153,38 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
       interfaces: [],
       fields: {},
     };
-    return combineClasses(cfg, data);
+    return combineClasses(config, data);
   }
 
   registerMetadata<T>(key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.register({});
-    return assignMetadata(key, cfg, data);
+    const config = this.register({});
+    return assignMetadata(key, config, data);
   }
 
   getMetadata<T>(key: symbol): T | undefined {
-    const md = this.#config?.metadata;
-    return castTo<T>(md?.[key]);
+    const metadata = this.#config?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
-  registerField(field: string | symbol, ...data: Partial<SchemaFieldConfig>[]): SchemaFieldConfig {
-    const config = this.register({});
-    const cfg = config.fields[field] ??= { name: field, owner: this.#cls, type: null! };
-    const combined = combineInputs(cfg, data);
+  registerField(field: string, ...data: Partial<SchemaFieldConfig>[]): SchemaFieldConfig {
+    const classConfig = this.register({});
+    const config = classConfig.fields[field] ??= { name: field, owner: this.#cls, type: null! };
+    const combined = combineInputs(config, data);
     return combined;
   }
 
-  registerFieldMetadata<T>(field: string | symbol, key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.registerField(field);
-    return assignMetadata(key, cfg, data);
+  registerFieldMetadata<T>(field: string, key: symbol, ...data: Partial<T>[]): T {
+    const config = this.registerField(field);
+    return assignMetadata(key, config, data);
   }
 
-  getFieldMetadata<T>(field: string | symbol, key: symbol): T | undefined {
-    const md = this.#config?.fields[field]?.metadata;
-    return castTo<T>(md?.[key]);
+  getFieldMetadata<T>(field: string, key: symbol): T | undefined {
+    const metadata = this.#config?.fields[field]?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
-  registerClass({ methods, ...cfg }: Partial<SchemaClassConfig> = {}): SchemaClassConfig {
-    this.register({ ...cfg });
+  registerClass({ methods, ...config }: Partial<SchemaClassConfig> = {}): SchemaClassConfig {
+    this.register({ ...config });
     if (methods?.[CONSTRUCTOR_PROPERTY]) {
       const { parameters, ...rest } = methods[CONSTRUCTOR_PROPERTY];
       this.registerMethod(CONSTRUCTOR_PROPERTY, rest);
@@ -195,36 +195,36 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     return this.#config;
   }
 
-  registerMethod(method: string | symbol, ...data: Partial<SchemaMethodConfig>[]): SchemaMethodConfig {
-    const config = this.register();
-    const cfg = config.methods[method] ??= { parameters: [], validators: [] };
-    return combineMethods(cfg, data);
+  registerMethod(method: string, ...data: Partial<SchemaMethodConfig>[]): SchemaMethodConfig {
+    const classConfig = this.register();
+    const config = classConfig.methods[method] ??= { parameters: [], validators: [] };
+    return combineMethods(config, data);
   }
 
-  registerMethodMetadata<T>(method: string | symbol, key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.registerMethod(method);
-    return assignMetadata(key, cfg, data);
+  registerMethodMetadata<T>(method: string, key: symbol, ...data: Partial<T>[]): T {
+    const config = this.registerMethod(method);
+    return assignMetadata(key, config, data);
   }
 
-  getMethodMetadata<T>(method: string | symbol, key: symbol): T | undefined {
-    const md = this.#config?.methods[method]?.metadata;
-    return castTo<T>(md?.[key]);
+  getMethodMetadata<T>(method: string, key: symbol): T | undefined {
+    const metadata = this.#config?.methods[method]?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
-  registerParameter(method: string | symbol, idx: number, ...data: Partial<SchemaParameterConfig>[]): SchemaParameterConfig {
+  registerParameter(method: string, idx: number, ...data: Partial<SchemaParameterConfig>[]): SchemaParameterConfig {
     const params = this.registerMethod(method, {}).parameters;
-    const cfg = params[idx] ??= { method, index: idx, owner: this.#cls, array: false, type: null! };
-    return combineInputs(cfg, data);
+    const config = params[idx] ??= { method, index: idx, owner: this.#cls, array: false, type: null! };
+    return combineInputs(config, data);
   }
 
-  registerParameterMetadata<T>(method: string | symbol, idx: number, key: symbol, ...data: Partial<T>[]): T {
-    const cfg = this.registerParameter(method, idx);
-    return assignMetadata(key, cfg, data);
+  registerParameterMetadata<T>(method: string, idx: number, key: symbol, ...data: Partial<T>[]): T {
+    const config = this.registerParameter(method, idx);
+    return assignMetadata(key, config, data);
   }
 
-  getParameterMetadata<T>(method: string | symbol, idx: number, key: symbol): T | undefined {
-    const md = this.#config?.methods[method]?.parameters[idx]?.metadata;
-    return castTo<T>(md?.[key]);
+  getParameterMetadata<T>(method: string, idx: number, key: symbol): T | undefined {
+    const metadata = this.#config?.methods[method]?.parameters[idx]?.metadata;
+    return castTo<T>(metadata?.[key]);
   }
 
   finalize(parent?: SchemaClassConfig): void {
@@ -256,13 +256,13 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
       const fields = config.views[view];
       const withoutSet = 'without' in fields ? new Set<string>(fields.without) : undefined;
       const fieldList = withoutSet ?
-        Object.keys(config.fields).filter(x => !withoutSet.has(x)) :
+        Object.keys(config.fields).filter(field => !withoutSet.has(field)) :
         ('with' in fields ? fields.with : []);
 
       this.#views.set(view,
-        fieldList.reduce<SchemaFieldMap>((acc, v) => {
-          acc[v] = config.fields[v];
-          return acc;
+        fieldList.reduce<SchemaFieldMap>((map, value) => {
+          map[value] = config.fields[value];
+          return map;
         }, {})
       );
     }
@@ -278,19 +278,19 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
     return this.#config;
   }
 
-  getField(field: string | symbol): SchemaFieldConfig {
+  getField(field: string): SchemaFieldConfig {
     return this.#config.fields[field];
   }
 
-  getMethod(method: string | symbol): SchemaMethodConfig {
-    const res = this.#config.methods[method];
-    if (!res) {
+  getMethod(method: string): SchemaMethodConfig {
+    const methodConfig = this.#config.methods[method];
+    if (!methodConfig) {
       throw new AppError(`Unknown method ${String(method)} on class ${this.#cls.Ⲑid}`);
     }
-    return res;
+    return methodConfig;
   }
 
-  getMethodReturnType(method: string | symbol): Class {
+  getMethodReturnType(method: string): Class {
     return this.getMethod(method).returnType!.type;
   }
 
@@ -321,13 +321,13 @@ export class SchemaRegistryAdapter implements RegistryAdapter<SchemaClassConfig>
   /**
    * Ensure type is set properly
    */
-  ensureInstanceTypeField<T>(o: T): T {
+  ensureInstanceTypeField<T>(value: T): T {
     const config = this.getDiscriminatedConfig();
     if (config) {
       const typeField = castKey<T>(config.discriminatedField);
-      o[typeField] ??= castTo(config.discriminatedType); // Assign if missing
+      value[typeField] ??= castTo(config.discriminatedType); // Assign if missing
     }
-    return o;
+    return value;
   }
 
   getDiscriminatedConfig(): Required<Pick<SchemaClassConfig, 'discriminatedType' | 'discriminatedField' | 'discriminatedBase'>> | undefined {

package/src/service/registry-index.ts

@@ -36,8 +36,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
     return this.#instance.getDiscriminatedTypes(cls);
   }
 
-  static resolveInstanceType<T>(cls: Class<T>, o: T): Class {
-    return this.#instance.resolveInstanceType(cls, o);
+  static resolveInstanceType<T>(cls: Class<T>, item: T): Class {
+    return this.#instance.resolveInstanceType(cls, item);
   }
 
   static visitFields<T>(cls: Class<T>, onField: (field: SchemaFieldConfig, path: SchemaFieldConfig[]) => void): void {
@@ -88,21 +88,21 @@ export class SchemaRegistryIndex implements RegistryIndex {
     Util.queueMacroTask().then(() => {
       SchemaChangeListener.emitFieldChanges({
         type: 'changed',
-        curr: this.getClassConfig(event.curr),
-        prev: this.getClassConfig(event.prev)
+        current: this.getClassConfig(event.current),
+        previous: this.getClassConfig(event.previous)
       });
     });
   }
 
   #onRemoving(event: ChangeEvent<Class> & { type: 'removing' }): void {
-    SchemaChangeListener.clearSchemaDependency(event.prev);
+    SchemaChangeListener.clearSchemaDependency(event.previous);
   }
 
   #onAdded(event: ChangeEvent<Class> & { type: 'added' }): void {
     Util.queueMacroTask().then(() => {
       SchemaChangeListener.emitFieldChanges({
         type: 'added',
-        curr: this.getClassConfig(event.curr)
+        current: this.getClassConfig(event.current)
       });
     });
   }
@@ -120,8 +120,8 @@ export class SchemaRegistryIndex implements RegistryIndex {
 
     // Rebuild indices after every "process" batch
     this.#byDiscriminatedTypes.clear();
-    for (const el of this.store.getClasses()) {
-      this.#registerDiscriminatedTypes(el);
+    for (const cls of this.store.getClasses()) {
+      this.#registerDiscriminatedTypes(cls);
     }
   }
 
@@ -134,15 +134,15 @@ export class SchemaRegistryIndex implements RegistryIndex {
    */
   getBaseClass(cls: Class): Class {
     if (!this.#baseSchema.has(cls)) {
-      let conf = this.getClassConfig(cls);
+      let config = this.getClassConfig(cls);
       let parent: Class | undefined = cls;
-      while (parent && conf.discriminatedType && !conf.discriminatedBase) {
+      while (parent && config.discriminatedType && !config.discriminatedBase) {
         parent = getParentClass(parent);
         if (parent) {
-          conf = this.store.getOptional(parent)?.get() ?? conf;
+          config = this.store.getOptional(parent)?.get() ?? config;
         }
       }
-      this.#baseSchema.set(cls, conf.class);
+      this.#baseSchema.set(cls, config.class);
     }
     return this.#baseSchema.get(cls)!;
   }
@@ -150,16 +150,16 @@ export class SchemaRegistryIndex implements RegistryIndex {
   /**
    * Find the resolved type for a given instance
    * @param cls Class for instance
-   * @param o Actual instance
+   * @param item Actual instance
    */
-  resolveInstanceType<T>(cls: Class<T>, o: T): Class {
+  resolveInstanceType<T>(cls: Class<T>, item: T): Class {
     const { discriminatedField, discriminatedType, class: targetClass } = this.store.get(cls).get();
     if (!discriminatedField) {
       return targetClass;
     } else {
       const base = this.getBaseClass(targetClass);
       const map = this.#byDiscriminatedTypes.get(base);
-      const type = castTo<string>(o[castKey<T>(discriminatedField)]) ?? discriminatedType;
+      const type = castTo<string>(item[castKey<T>(discriminatedField)]) ?? discriminatedType;
       if (!type) {
         throw new AppError(`Unable to resolve discriminated type for class ${base.name} without a type`);
       }
@@ -177,13 +177,13 @@ export class SchemaRegistryIndex implements RegistryIndex {
   /**
    * Track changes to schemas, and track the dependent changes
    * @param cls The root class of the hierarchy
-   * @param curr The new class
+   * @param current The new class
    * @param path The path within the object hierarchy
    */
-  trackSchemaDependencies(cls: Class, curr: Class = cls, path: SchemaFieldConfig[] = []): void {
-    const config = this.getClassConfig(curr);
+  trackSchemaDependencies(cls: Class, current: Class = cls, path: SchemaFieldConfig[] = []): void {
+    const config = this.getClassConfig(current);
 
-    SchemaChangeListener.trackSchemaDependency(curr, cls, path, this.getClassConfig(cls));
+    SchemaChangeListener.trackSchemaDependency(current, cls, path, this.getClassConfig(cls));
 
     // Read children
     for (const field of Object.values(config.fields)) {