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

package/src/validate/validator.ts

@@ -5,25 +5,25 @@ import { ValidationError, ValidationKindCore, ValidationResult } from './types.t
 import { Messages } from './messages.ts';
 import { isValidationError, TypeMismatchError, ValidationResultError } from './error.ts';
 import { DataUtil } from '../data.ts';
-import { CommonRegExpToName } from './regexp.ts';
+import { CommonRegexToName } from './regex.ts';
 import { SchemaRegistryIndex } from '../service/registry-index.ts';
 
 /**
  * Get the schema config for Class/Schema config, including support for polymorphism
  * @param base The starting type or config
- * @param o The value to use for the polymorphic check
+ * @param item The item to use for the polymorphic check
  */
-function resolveFieldMap<T>(base: Class<T>, o: T): SchemaFieldMap {
-  const target = SchemaRegistryIndex.resolveInstanceType(base, o);
+function resolveFieldMap<T>(base: Class<T>, item: T): SchemaFieldMap {
+  const target = SchemaRegistryIndex.resolveInstanceType(base, item);
   return SchemaRegistryIndex.get(target).getFields();
 }
 
-function isClassInstance<T>(o: unknown): o is ClassInstance<T> {
-  return !DataUtil.isPlainObject(o) && o !== null && typeof o === 'object' && !!o.constructor;
+function isClassInstance<T>(value: unknown): value is ClassInstance<T> {
+  return !DataUtil.isPlainObject(value) && value !== null && typeof value === 'object' && !!value.constructor;
 }
 
-function isRangeValue(o: unknown): o is number | string | Date {
-  return typeof o === 'string' || typeof o === 'number' || o instanceof Date;
+function isRangeValue(value: unknown): value is number | string | Date {
+  return typeof value === 'string' || typeof value === 'number' || value instanceof Date;
 }
 
 /**
@@ -35,15 +35,15 @@ export class SchemaValidator {
   /**
    * Validate the schema for a given object
    * @param fields The config to validate against
-   * @param o The object to validate
+   * @param item The object to validate
    * @param relative The relative path as the validation recurses
    */
-  static #validateFields<T>(fields: SchemaFieldMap, o: T, relative: string): ValidationError[] {
+  static #validateFields<T>(fields: SchemaFieldMap, item: T, relative: string): ValidationError[] {
     let errors: ValidationError[] = [];
 
     for (const [field, fieldConfig] of TypedObject.entries(fields)) {
       if (fieldConfig.access !== 'readonly') { // Do not validate readonly fields
-        errors = errors.concat(this.#validateInputSchema(fieldConfig, o[castKey<T>(field)], relative));
+        errors = errors.concat(this.#validateInputSchema(fieldConfig, item[castKey<T>(field)], relative));
       }
     }
 
@@ -53,13 +53,13 @@ export class SchemaValidator {
   /**
    * Validate a single input config against a passed in value
    * @param input The input schema configuration
-   * @param val The raw value, could be an array or not
+   * @param value The raw value, could be an array or not
    * @param relative The relative path of object traversal
    */
-  static #validateInputSchema(input: SchemaInputConfig, val: unknown, relative: string = ''): ValidationError[] {
+  static #validateInputSchema(input: SchemaInputConfig, value: unknown, relative: string = ''): ValidationError[] {
     const key = 'name' in input ? input.name : ('index' in input ? input.index : 'unknown');
     const path = `${relative}${relative ? '.' : ''}${key}`;
-    const hasValue = !(val === undefined || val === null || (typeof val === 'string' && val === '') || (Array.isArray(val) && val.length === 0));
+    const hasValue = !(value === undefined || value === null || (typeof value === 'string' && value === '') || (Array.isArray(value) && value.length === 0));
 
     if (!hasValue) {
       if (input.required?.active !== false) {
@@ -75,26 +75,26 @@ export class SchemaValidator {
     if (type === Object) {
       return [];
     } else if (array) {
-      if (!Array.isArray(val)) {
-        return this.#prepareErrors(path, [{ kind: 'type', type: Array, value: val }]);
+      if (!Array.isArray(value)) {
+        return this.#prepareErrors(path, [{ kind: 'type', type: Array, value }]);
       }
       let errors: ValidationError[] = [];
       if (complex) {
-        for (let i = 0; i < val.length; i++) {
-          const subErrors = this.#validateFields(resolveFieldMap(type, val[i]), val[i], `${path}[${i}]`);
+        for (let i = 0; i < value.length; i++) {
+          const subErrors = this.#validateFields(resolveFieldMap(type, value[i]), value[i], `${path}[${i}]`);
           errors = errors.concat(subErrors);
         }
       } else {
-        for (let i = 0; i < val.length; i++) {
-          const subErrors = this.#validateInput(input, val[i]);
+        for (let i = 0; i < value.length; i++) {
+          const subErrors = this.#validateInput(input, value[i]);
           errors.push(...this.#prepareErrors(`${path}[${i}]`, subErrors));
         }
       }
       return errors;
     } else if (complex) {
-      return this.#validateFields(resolveFieldMap(type, val), val, path);
+      return this.#validateFields(resolveFieldMap(type, value), value, path);
     } else {
-      const fieldErrors = this.#validateInput(input, val);
+      const fieldErrors = this.#validateInput(input, value);
       return this.#prepareErrors(path, fieldErrors);
     }
   }
@@ -106,13 +106,13 @@ export class SchemaValidator {
    * @param value The value to validate
    */
   static #validateRange(input: SchemaInputConfig, key: 'min' | 'max', value: string | number | Date): boolean {
-    const f = input[key]!;
-    const valueNum = (typeof value === 'string') ?
+    const config = input[key]!;
+    const parsed = (typeof value === 'string') ?
       (input.type === Date ? Date.parse(value) : parseInt(value, 10)) :
       (value instanceof Date ? value.getTime() : value);
 
-    const boundary = (typeof f.n === 'number' ? f.n : f.n.getTime());
-    return key === 'min' ? valueNum < boundary : valueNum > boundary;
+    const boundary = (typeof config.limit === 'number' ? config.limit : config.limit.getTime());
+    return key === 'min' ? parsed < boundary : parsed > boundary;
   }
 
   /**
@@ -144,15 +144,15 @@ export class SchemaValidator {
       }
     }
 
-    if (input.match && !input.match.re.test(`${value}`)) {
+    if (input.match && !input.match.regex.test(`${value}`)) {
       criteria.push(['match', input.match]);
     }
 
-    if (input.minlength && `${value}`.length < input.minlength.n) {
+    if (input.minlength && `${value}`.length < input.minlength.limit) {
       criteria.push(['minlength', input.minlength]);
     }
 
-    if (input.maxlength && `${value}`.length > input.maxlength.n) {
+    if (input.maxlength && `${value}`.length > input.maxlength.limit) {
       criteria.push(['maxlength', input.maxlength]);
     }
 
@@ -184,30 +184,30 @@ export class SchemaValidator {
   static #prepareErrors(path: string, results: ValidationResult[]): ValidationError[] {
     const out: ValidationError[] = [];
     for (const result of results) {
-      const err: ValidationError = {
+      const error: ValidationError = {
         ...result,
         kind: result.kind,
         value: result.value,
         message: '',
-        re: CommonRegExpToName.get(result.re!) ?? result.re?.source ?? '',
+        regex: CommonRegexToName.get(result.regex!) ?? result.regex?.source ?? '',
         path,
         type: (typeof result.type === 'function' ? result.type.name : result.type)
       };
 
-      if (!err.re) {
-        delete err.re;
+      if (!error.regex) {
+        delete error.regex;
       }
 
       const msg = result.message ?? (
-        Messages.get(err.re ?? '') ??
-        Messages.get(err.kind) ??
+        Messages.get(error.regex ?? '') ??
+        Messages.get(error.kind) ??
         Messages.get('default')!
       );
 
-      err.message = msg
-        .replace(/\{([^}]+)\}/g, (_, k: (keyof ValidationError)) => `${err[k]}`);
+      error.message = msg
+        .replace(/\{([^}]+)\}/g, (_, key: (keyof ValidationError)) => `${error[key]}`);
 
-      out.push(err);
+      out.push(error);
     }
     return out;
   }
@@ -215,7 +215,7 @@ export class SchemaValidator {
   /**
    * Validate the class level validations
    */
-  static async #validateClassLevel<T>(cls: Class<T>, o: T, view?: string): Promise<ValidationError[]> {
+  static async #validateClassLevel<T>(cls: Class<T>, item: T, view?: string): Promise<ValidationError[]> {
     if (!SchemaRegistryIndex.has(cls)) {
       return [];
     }
@@ -226,19 +226,19 @@ export class SchemaValidator {
     // Handle class level validators
     for (const fn of classConfig.validators) {
       try {
-        const res = await fn(o, view);
-        if (res) {
-          if (Array.isArray(res)) {
-            errors.push(...res);
+        const error = await fn(item, view);
+        if (error) {
+          if (Array.isArray(error)) {
+            errors.push(...error);
           } else {
-            errors.push(res);
+            errors.push(error);
           }
         }
-      } catch (err: unknown) {
-        if (isValidationError(err)) {
-          errors.push(err);
+      } catch (error: unknown) {
+        if (isValidationError(error)) {
+          errors.push(error);
         } else {
-          throw err;
+          throw error;
         }
       }
     }
@@ -248,60 +248,60 @@ export class SchemaValidator {
   /**
    * Validate an object against it's constructor's schema
    * @param cls The class to validate the objects against
-   * @param o The object to validate
+   * @param item The object to validate
    * @param view The optional view to limit the scope to
    */
-  static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
-    if (isClassInstance(o) && !(o instanceof cls || cls.Ⲑid === o.constructor.Ⲑid)) {
-      throw new TypeMismatchError(cls.name, o.constructor.name);
+  static async validate<T>(cls: Class<T>, item: T, view?: string): Promise<T> {
+    if (isClassInstance(item) && !(item instanceof cls || cls.Ⲑid === item.constructor.Ⲑid)) {
+      throw new TypeMismatchError(cls.name, item.constructor.name);
     }
-    cls = SchemaRegistryIndex.resolveInstanceType(cls, o);
+    cls = SchemaRegistryIndex.resolveInstanceType(cls, item);
 
     const fields = SchemaRegistryIndex.get(cls).getFields(view);
 
     // Validate using standard behaviors
     const errors = [
-      ...this.#validateFields(fields, o, ''),
-      ... await this.#validateClassLevel(cls, o, view)
+      ...this.#validateFields(fields, item, ''),
+      ... await this.#validateClassLevel(cls, item, view)
     ];
     if (errors.length) {
       throw new ValidationResultError(errors);
     }
 
-    return o;
+    return item;
   }
 
   /**
    * Validate an entire array of values
    * @param cls The class to validate the objects against
-   * @param obj The values to validate
+   * @param items The values to validate
    * @param view The view to limit by
    */
-  static async validateAll<T>(cls: Class<T>, obj: T[], view?: string): Promise<T[]> {
-    return await Promise.all<T>((obj ?? [])
-      .map(o => this.validate(cls, o, view)));
+  static async validateAll<T>(cls: Class<T>, items: T[], view?: string): Promise<T[]> {
+    return await Promise.all<T>((items ?? [])
+      .map(item => this.validate(cls, item, view)));
   }
 
   /**
    * Validate partial, ignoring required fields as they are partial
    *
    * @param cls The class to validate against
-   * @param o The value to validate
+   * @param item The value to validate
    * @param view The view to limit by
    */
-  static async validatePartial<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
+  static async validatePartial<T>(cls: Class<T>, item: T, view?: string): Promise<T> {
     try {
-      await this.validate(cls, o, view);
-    } catch (err) {
-      if (err instanceof ValidationResultError) { // Don't check required fields
-        const errs = err.details.errors.filter(x => x.kind !== 'required');
+      await this.validate(cls, item, view);
+    } catch (error) {
+      if (error instanceof ValidationResultError) { // Don't check required fields
+        const errs = error.details.errors.filter(validationError => validationError.kind !== 'required');
         if (errs.length) {
-          err.details.errors = errs;
-          throw err;
+          error.details.errors = errs;
+          throw error;
         }
       }
     }
-    return o;
+    return item;
   }
 
   /**
@@ -311,7 +311,7 @@ export class SchemaValidator {
    * @param method The method being invoked
    * @param params The params to validate
    */
-  static async validateMethod<T>(cls: Class<T>, method: string | symbol, params: unknown[], prefixes: (string | symbol | undefined)[] = []): Promise<void> {
+  static async validateMethod<T>(cls: Class<T>, method: string, params: unknown[], prefixes: (string | undefined)[] = []): Promise<void> {
     const errors: ValidationError[] = [];
     const config = SchemaRegistryIndex.get(cls).getMethod(method);
 
@@ -320,22 +320,22 @@ export class SchemaValidator {
       errors.push(...[
         ... this.#validateInputSchema(param, params[i]),
         ... await this.#validateClassLevel(param.type, params[i])
-      ].map(x => {
+      ].map(error => {
         if (param.name && typeof param.name === 'string') {
-          x.path = !prefixes[i] ?
-            x.path.replace(`${param.name}.`, '') :
-            x.path.replace(param.name, prefixes[i]!.toString());
+          error.path = !prefixes[i] ?
+            error.path.replace(`${param.name}.`, '') :
+            error.path.replace(param.name, prefixes[i]!);
         }
-        return x;
+        return error;
       }));
     }
     for (const validator of config.validators) {
-      const res = await validator(...params);
-      if (res) {
-        if (Array.isArray(res)) {
-          errors.push(...res);
+      const error = await validator(...params);
+      if (error) {
+        if (Array.isArray(error)) {
+          errors.push(...error);
         } else {
-          errors.push(res);
+          errors.push(error);
         }
       }
     }

package/support/transformer/util.ts

@@ -22,7 +22,7 @@ export class SchemaTransformUtil {
     switch (type.key) {
       case 'pointer': return this.toConcreteType(state, type.target, node, root);
       case 'managed': return state.getOrImport(type);
-      case 'tuple': return state.fromLiteral(type.subTypes.map(x => this.toConcreteType(state, x, node, root)!));
+      case 'tuple': return state.fromLiteral(type.subTypes.map(subType => this.toConcreteType(state, subType, node, root)!));
       case 'template': return state.createIdentifier(type.ctor.name);
       case 'literal': {
         if ((type.ctor === Array) && type.typeArguments?.length) {
@@ -60,7 +60,7 @@ class ${uniqueId} extends ${type.mappedClassName} {
       }
       case 'unknown': {
         const imp = state.importFile(this.TYPES_IMPORT);
-        return state.createAccess(imp.ident, 'UnknownType');
+        return state.createAccess(imp.identifier, 'UnknownType');
       }
       case 'shape': {
         const uniqueId = state.generateUniqueIdentifier(node, type, 'Δ');
@@ -76,18 +76,18 @@ class ${uniqueId} extends ${type.mappedClassName} {
             ],
             id, [], [],
             Object.entries(type.fieldTypes)
-              .map(([k, v]) =>
+              .map(([key, value]) =>
                 this.computeInput(state, state.factory.createPropertyDeclaration(
-                  [], /\W/.test(k) ? state.factory.createComputedPropertyName(state.fromLiteral(k)) : k,
-                  v.undefinable || v.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-                  v.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
-                ), { type: v, root })
+                  [], /\W/.test(key) ? state.factory.createComputedPropertyName(state.fromLiteral(key)) : key,
+                  value.undefinable || value.nullable ? state.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+                  value.key === 'unknown' ? state.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword) : undefined, undefined
+                ), { type: value, root })
               )
           );
           cls.getText = (): string => [
             `class ${uniqueId} {`,
             ...Object.entries(type.fieldTypes)
-              .map(([k, v]) => `  ${k}${v.nullable ? '?' : ''}: ${v.name};`),
+              .map(([key, value]) => `  ${key}${value.nullable ? '?' : ''}: ${value.name};`),
             '}'
           ].join('\n');
           state.addStatements([cls], root || node);
@@ -135,12 +135,12 @@ class ${uniqueId} extends ${type.mappedClassName} {
         attrs.default = node.initializer;
       }
     } else {
-      const acc = DeclarationUtil.getAccessorPair(node);
+      const pair = DeclarationUtil.getAccessorPair(node);
       attrs.accessor = true;
-      if (!acc.setter) {
+      if (!pair.setter) {
         attrs.access = 'readonly';
       }
-      if (!acc.getter) {
+      if (!pair.getter) {
         attrs.access = 'writeonly';
       } else if (!!typeExpr.undefinable) {
         attrs.required = { active: false };
@@ -160,8 +160,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
     // We need to ensure we aren't being tripped up by the wrapper for arrays, sets, etc.
     // If we have a composition type
     if (primaryExpr.key === 'composition') {
-      const values = primaryExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
-        .filter(x => x !== undefined && x !== null);
+      const values = primaryExpr.subTypes
+        .map(subType => subType.key === 'literal' ? subType.value : undefined)
+        .filter(value => value !== undefined && value !== null);
 
       if (values.length === primaryExpr.subTypes.length) {
         attrs.enum = {
@@ -170,17 +171,19 @@ class ${uniqueId} extends ${type.mappedClassName} {
         };
       }
     } else if (primaryExpr.key === 'template' && primaryExpr.template) {
-      const re = LiteralUtil.templateLiteralToRegex(primaryExpr.template);
+      const regex = LiteralUtil.templateLiteralToRegex(primaryExpr.template);
       attrs.match = {
-        re: new RegExp(re),
+        regex: new RegExp(regex),
         template: primaryExpr.template,
-        message: `{path} must match "${re}"`
+        message: `{path} must match "${regex}"`
       };
     }
 
     if (ts.isParameter(node)) {
       const parentComments = DocUtil.describeDocs(node.parent);
-      const paramComments: Partial<ParamDocumentation> = (parentComments.params ?? []).find(x => x.name === node.name.getText()) || {};
+      const paramComments: Partial<ParamDocumentation> = (parentComments.params ?? [])
+        .find(param => param.name === node.name.getText()) || {};
+
       if (paramComments.description) {
         attrs.description = paramComments.description;
       }
@@ -192,9 +195,9 @@ class ${uniqueId} extends ${type.mappedClassName} {
     }
 
     const tags = ts.getJSDocTags(node);
-    const aliases = tags.filter(x => x.tagName.getText() === 'alias');
+    const aliases = tags.filter(tag => tag.tagName.getText() === 'alias');
     if (aliases.length) {
-      attrs.aliases = aliases.map(x => x.comment).filter(x => !!x);
+      attrs.aliases = aliases.map(alias => alias.comment).filter(alias => !!alias);
     }
 
     const params: ts.Expression[] = [];
@@ -241,15 +244,15 @@ class ${uniqueId} extends ${type.mappedClassName} {
   ): T {
     const existingField = state.findDecorator('@travetto/schema', node, 'Field', this.FIELD_IMPORT);
     const existingInput = state.findDecorator('@travetto/schema', node, 'Input', this.INPUT_IMPORT);
-    const decParams = this.computeInputDecoratorParams(state, node, config);
+    const params = this.computeInputDecoratorParams(state, node, config);
 
     let modifiers: ts.ModifierLike[];
     if (existingField) {
-      const dec = state.createDecorator(this.FIELD_IMPORT, 'Field', ...decParams);
-      modifiers = DecoratorUtil.spliceDecorators(node, existingField, [dec]);
+      const decorator = state.createDecorator(this.FIELD_IMPORT, 'Field', ...params);
+      modifiers = DecoratorUtil.spliceDecorators(node, existingField, [decorator]);
     } else {
-      const dec = state.createDecorator(this.INPUT_IMPORT, 'Input', ...decParams);
-      modifiers = DecoratorUtil.spliceDecorators(node, existingInput, [dec]);
+      const decorator = state.createDecorator(this.INPUT_IMPORT, 'Input', ...params);
+      modifiers = DecoratorUtil.spliceDecorators(node, existingInput, [decorator]);
     }
 
     let result: unknown;
@@ -324,8 +327,8 @@ class ${uniqueId} extends ${type.mappedClassName} {
     let cls;
     switch (type?.key) {
       case 'managed': {
-        const [dec] = DeclarationUtil.getDeclarations(type.original!);
-        cls = dec && ts.isClassDeclaration(dec) ? dec : undefined;
+        const [decorator] = DeclarationUtil.getDeclarations(type.original!);
+        cls = decorator && ts.isClassDeclaration(decorator) ? decorator : undefined;
         break;
       }
       case 'shape': cls = type.original; break;

package/support/transformer.schema.ts

@@ -59,8 +59,8 @@ export class SchemaTransformer {
     // Determine auto enrol methods
     for (const item of state.getDecoratorList(node)) {
       if (item.targets?.includes('@travetto/schema:Schema')) {
-        for (const opt of item.options ?? []) {
-          state[AutoEnrollMethods].add(opt);
+        for (const option of item.options ?? []) {
+          state[AutoEnrollMethods].add(option);
         }
       }
     }
@@ -76,7 +76,7 @@ export class SchemaTransformer {
     const comments = DocUtil.describeDocs(node);
 
     const existing = state.findDecorator(this, node, 'Schema', SchemaTransformUtil.SCHEMA_IMPORT);
-    const cons = node.members.find(x => ts.isConstructorDeclaration(x));
+    const cons = node.members.find(member => ts.isConstructorDeclaration(member));
 
     const attrs: Record<string, string | boolean | ts.Expression | number | object | unknown[]> = {};
 
@@ -105,9 +105,9 @@ export class SchemaTransformer {
     if (cons) {
       attrs.methods = {
         [CONSTRUCTOR_PROPERTY]: {
-          parameters: cons.parameters.map((p, i) => SchemaTransformUtil.computeInputDecoratorParams(state, p, { index: i })).map(x =>
-            state.extendObjectLiteral({}, ...x)
-          ),
+          parameters: cons.parameters
+            .map((parameter, i) => SchemaTransformUtil.computeInputDecoratorParams(state, parameter, { index: i }))
+            .map(expr => state.extendObjectLiteral({}, ...expr)),
         }
       };
     }
@@ -163,7 +163,7 @@ export class SchemaTransformer {
       node.name,
       node.questionToken,
       node.typeParameters,
-      node.parameters.map((y, i) => SchemaTransformUtil.computeInput(state, y, { index: i })),
+      node.parameters.map((parameter, i) => SchemaTransformUtil.computeInput(state, parameter, { index: i })),
       node.type,
       node.body
     );

package/src/service/changes.ts

@@ -1,152 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { Class } from '@travetto/runtime';
-import { ChangeEvent } from '@travetto/registry';
-
-import { SchemaFieldConfig, SchemaClassConfig } from './types.ts';
-
-interface FieldMapping {
-  path: SchemaFieldConfig[];
-  config: SchemaClassConfig;
-}
-
-export interface FieldChangeEvent {
-  cls: Class;
-  changes: ChangeEvent<SchemaFieldConfig>[];
-}
-
-interface SubSchemaChange {
-  path: SchemaFieldConfig[];
-  fields: ChangeEvent<SchemaFieldConfig>[];
-}
-
-export interface SchemaChange {
-  config: SchemaClassConfig;
-  subs: SubSchemaChange[];
-}
-
-export interface SchemaChangeEvent {
-  cls: Class;
-  change: SchemaChange;
-}
-
-/**
- * Schema change listener.  Handles all changes that occur via the SchemaRegistryIndex
- */
-class $SchemaChangeListener {
-
-  #emitter = new EventEmitter();
-  #mapping = new Map<string, Map<string, FieldMapping>>();
-
-  /**
-   * On schema change, emit the change event for the whole schema
-   * @param cb The function to call on schema change
-   */
-  onSchemaChange(handler: (e: 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
-   */
-  onFieldChange(handler: (e: FieldChangeEvent) => void): void {
-    this.#emitter.on('field', handler);
-  }
-
-  /**
-   * Clear dependency mappings for a given class
-   */
-  clearSchemaDependency(cls: Class): void {
-    this.#mapping.delete(cls.Ⲑid);
-  }
-
-  /**
-   * Track a specific class for dependencies
-   * @param src 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;
-    if (!this.#mapping.has(idValue)) {
-      this.#mapping.set(idValue, new Map());
-    }
-    this.#mapping.get(idValue)!.set(parent.Ⲑid, { path, config });
-  }
-
-  /**
-   * Emit changes to the schema
-   * @param cls The class of the event
-   * @param changes The changes to send
-   */
-  emitSchemaChanges({ cls, changes }: FieldChangeEvent): void {
-    const updates = new Map<string, SchemaChange>();
-    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 c = deps.get(depClsId)!;
-        updates.get(depClsId)!.subs.push({ path: [...c.path], fields: changes });
-      }
-    }
-
-    for (const key of updates.keys()) {
-      this.#emitter.emit('schema', { cls: updates.get(key)!.config.class, change: updates.get(key)! });
-    }
-  }
-
-  /**
-   * Emit field level changes in the schema
-   * @param prev The previous class config
-   * @param curr 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;
-
-    const prevFields = new Set(Object.keys(prev?.fields ?? {}));
-    const currFields = new Set(Object.keys(curr?.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 c of prevFields) {
-      if (!currFields.has(c) && prev) {
-        changes.push({ prev: prev.fields[c], 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];
-        if (
-          JSON.stringify(prevSchema) !== JSON.stringify(currSchema) ||
-          !compareTypes(prevSchema.type, currSchema.type)
-        ) {
-          changes.push({ prev: prev.fields[c], curr: curr.fields[c], type: 'changed' });
-        }
-      }
-    }
-
-    // Send field changes
-    this.#emitter.emit('field', { cls: curr!.class, changes });
-    this.emitSchemaChanges({ cls: curr!.class, changes });
-  }
-}
-
-export const SchemaChangeListener = new $SchemaChangeListener();