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

package/README.md

@@ -20,9 +20,9 @@ Registration, within the framework flows throw two main use cases:
 
 ### Initial Flows
 The primary flow occurs on initialization of the application. At that point, the module will:
-   1. Initialize [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/registry.ts#L9) and will automatically register/load all relevant files
+   1. Initialize [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/registry.ts#L5) and will automatically register/load all relevant files
    1. As files are imported, decorators within the files will record various metadata relevant to the respective registries
-   1. When all files are processed, the [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/registry.ts#L9) is finished, and it will signal to anything waiting on registered data that its free to use it.
+   1. When all files are processed, the [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/registry.ts#L5) is finished, and it will signal to anything waiting on registered data that its free to use it.
 
 This flow ensures all files are loaded and processed before application starts. A sample registry could like:
 
@@ -54,13 +54,13 @@ class SampleRegistryAdapter implements RegistryAdapter<Group> {
     this.#class = cls;
   }
 
-  register(...data: Partial<Partial<Group>>[]): Group {
-    for (const d of data) {
+  register(...groups: Partial<Partial<Group>>[]): Group {
+    for (const group of groups) {
       Object.assign(this.#config, {
-        ...d,
+        ...group,
         children: [
           ...(this.#config?.children ?? []),
-          ...(d.children ?? [])
+          ...(group.children ?? [])
         ]
       });
     }
@@ -98,57 +98,7 @@ export class SampleRegistryIndex implements RegistryIndex {
 }
 ```
 
-The registry index is a [RegistryIndex](https://github.com/travetto/travetto/tree/main/module/registry/src/service/types.ts#L36) that similar to the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.")'s Schema registry and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.")'s Dependency registry.
+The registry index is a [RegistryIndex](https://github.com/travetto/travetto/tree/main/module/registry/src/types.ts#L32) that similar to the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.")'s Schema registry and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.")'s Dependency registry.
 
 ### Live Flow
-At runtime, the registry is designed to listen for changes and to propagate the changes as necessary. In many cases the same file is handled by multiple registries. 
-
-As the [DynamicFileLoader](https://github.com/travetto/travetto/tree/main/module/registry/src/internal/file-loader.ts#L17) notifies that a file has been changed, the [Registry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/registry.ts#L9) will pick it up, and process it accordingly.
-
-## Supporting Metadata
-As mentioned in [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching")'s readme, the framework produces hashes of methods, classes, and functions, to allow for detecting changes to individual parts of the codebase. During the live flow, various registries will inspect this information to determine if action should be taken.
-
-**Code: Sample Class Diffing**
-```typescript
-
-#handleFileChanges(importFile: string, classes: Class[] = []): number {
-    const next = new Map<string, Class>(classes.map(cls => [cls.Ⲑid, cls] as const));
-    const sourceFile = RuntimeIndex.getSourceFile(importFile);
-
-    let prev = new Map<string, Class>();
-    if (this.#classes.has(sourceFile)) {
-      prev = new Map(this.#classes.get(sourceFile)!.entries());
-    }
-
-    const keys = new Set([...Array.from(prev.keys()), ...Array.from(next.keys())]);
-
-    if (!this.#classes.has(sourceFile)) {
-      this.#classes.set(sourceFile, new Map());
-    }
-
-    let changes = 0;
-
-    // Determine delta based on the various classes (if being added, removed or updated)
-    for (const k of keys) {
-      if (!next.has(k)) {
-        changes += 1;
-        this.emit({ type: 'removing', prev: prev.get(k)! });
-        this.#classes.get(sourceFile)!.delete(k);
-      } else {
-        this.#classes.get(sourceFile)!.set(k, next.get(k)!);
-        if (!prev.has(k)) {
-          changes += 1;
-          this.emit({ type: 'added', curr: next.get(k)! });
-        } else {
-          const prevHash = describeFunction(prev.get(k)!)?.hash;
-          const nextHash = describeFunction(next.get(k)!)?.hash;
-          if (prevHash !== nextHash) {
-            changes += 1;
-            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k)! });
-          }
-        }
-      }
-    }
-    return changes;
-  }
-```
+At runtime, the framework is designed to listen for changes and restart any running processes as needed.

package/__index__.ts

@@ -1,7 +1,3 @@
-export * from './src/service/registry.ts';
-export * from './src/service/types.ts';
-export * from './src/service/store.ts';
-export * from './src/proxy.ts';
-export * from './src/source/class-source.ts';
-export * from './src/source/method-source.ts';
-export * from './src/types.ts';
+export * from './src/registry.ts';
+export * from './src/types.ts';
+export * from './src/store.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/registry",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Patterns and utilities for handling registration of metadata and functionality for run-time use",
   "keywords": [
     "ast-transformations",
@@ -27,11 +27,11 @@
     "directory": "module/registry"
   },
   "dependencies": {
-    "@travetto/runtime": "^7.0.0-rc.1"
+    "@travetto/runtime": "^7.0.0-rc.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.1",
-    "@travetto/transformer": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.3",
+    "@travetto/transformer": "^7.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/registry.ts

@@ -0,0 +1,147 @@
+import { AppError, castTo, type Class, Env, flushPendingFunctions, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
+
+import type { RegistryIndex, RegistryIndexClass } from './types';
+
+class $Registry {
+
+  #resolved = false;
+  #initialized?: Promise<unknown>;
+  #indexByClass = new Map<RegistryIndexClass, RegistryIndex>();
+  #indexes: RegistryIndex[] = [];
+
+  #finalizeItems(classes: Class[]): void {
+    for (const index of this.#indexes) {
+      for (const cls of classes) {
+        if (index.store.has(cls) && !index.store.finalized(cls)) {
+          if (index.finalize) {
+            index.finalize(cls);
+          } else {
+            index.store.finalize(cls);
+          }
+        }
+      }
+    }
+  }
+
+  trace = false;
+
+  validateConstructor(source: unknown): void {
+    if (source !== this) {
+      throw new AppError('constructor is private');
+    }
+  }
+
+  finalizeForIndex(indexCls: RegistryIndexClass): void {
+    const inst = this.instance(indexCls);
+    this.#finalizeItems(inst.store.getClasses());
+  }
+
+  /**
+   * Process change events
+   */
+  process(classes: Class[]): void {
+    this.#finalizeItems(classes);
+
+    const byIndex = new Map<RegistryIndex, Class[]>();
+    for (const index of this.#indexes) {
+      byIndex.set(index, classes.filter(cls => index.store.has(cls)));
+    }
+
+    for (const index of this.#indexes) {
+      for (const cls of byIndex.get(index)!) {
+        index.onCreate?.(cls);
+      }
+      index.beforeChangeSetComplete?.(byIndex.get(index)!);
+    }
+
+    // Call after everything is done
+    for (const index of this.#indexes) {
+      index.onChangeSetComplete?.(byIndex.get(index)!);
+    }
+  }
+
+  /**
+   * Run initialization
+   */
+  async #init(): Promise<void> {
+    try {
+      this.#resolved = false;
+
+      if (this.trace) {
+        console.debug('Initializing');
+      }
+
+      // Ensure everything is loaded
+      for (const entry of RuntimeIndex.find({
+        module: (mod) => {
+          const role = Env.TRV_ROLE.value;
+          return role !== 'test' && // Skip all modules when in test
+            mod.roles.includes('std') &&
+            (
+              !Runtime.production || mod.prod ||
+              (role === 'doc' && mod.roles.includes(role))
+            );
+        },
+        folder: folder => folder === 'src' || folder === '$index'
+      })) {
+        await Runtime.importFrom(entry.import);
+      }
+
+      // Flush all load events
+      const added = flushPendingFunctions().filter(isClass);
+      this.process(added);
+    } finally {
+      this.#resolved = true;
+    }
+  }
+
+  /**
+   * Verify initialized state
+   */
+  verifyInitialized(): void {
+    if (!this.#resolved) {
+      throw new AppError('Registry not initialized, call init() first');
+    }
+  }
+
+  /**
+   * Register a new index
+   */
+  registerIndex<T extends RegistryIndexClass>(indexCls: T): InstanceType<T> {
+    if (!this.#indexByClass.has(indexCls)) {
+      const instance = new indexCls(this);
+      this.#indexByClass.set(indexCls, instance);
+      this.#indexes.push(instance);
+    }
+    return castTo(this.#indexByClass.get(indexCls));
+  }
+
+  /**
+   * Initialize, with a built-in latch to prevent concurrent initializations
+   */
+  async init(): Promise<unknown> {
+    if (this.trace && this.#initialized) {
+      console.trace('Trying to re-initialize', { initialized: !!this.#initialized });
+    }
+    return this.#initialized ??= this.#init();
+  }
+
+  /**
+   * Manual init, not meant to be used directly
+   * @private
+   */
+  async manualInit(files: string[]): Promise<Class[]> {
+    for (const file of files) {
+      await Runtime.importFrom(file);
+    }
+    const imported = flushPendingFunctions().filter(isClass);
+    this.process(imported);
+    return imported;
+  }
+
+  instance<T extends RegistryIndexClass>(indexCls: T): InstanceType<T> {
+    return castTo(this.#indexByClass.get(indexCls));
+  }
+}
+
+export const Registry = new $Registry();

package/src/{service/store.ts → store.ts}

@@ -1,27 +1,11 @@
-import { Any, AppError, castTo, Class, getParentClass, Runtime } from '@travetto/runtime';
+import { AppError, castTo, type Class, getParentClass } from '@travetto/runtime';
 
-import { EXPIRED_CLASS, RegistrationMethods, RegistryAdapter } from './types';
-
-function ExchangeExpired<R = unknown>() {
-  return function (
-    target: Any,
-    propertyKey: string | symbol,
-    descriptor: TypedPropertyDescriptor<(this: RegistryIndexStore, cls: Class) => R>
-  ): void {
-    if (Runtime.dynamic) {
-      const original = descriptor.value!;
-      descriptor.value = function (this: RegistryIndexStore, cls: Class): R {
-        const resolved = EXPIRED_CLASS in cls ? this.getClassById(cls.Ⲑid) : cls;
-        return original.apply(this, [resolved]);
-      };
-    }
-  };
-}
+import type { RegistrationMethods, RegistryAdapter, RegistrySimpleStore } from './types';
 
 /**
  * Base registry index implementation
  */
-export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<{}>> {
+export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<{}>> implements RegistrySimpleStore {
 
   // Core data
   #adapters = new Map<Class, A>();
@@ -51,17 +35,10 @@ export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<
     this.#finalized.set(cls, true);
   }
 
-  remove(cls: Class): void {
-    this.#adapters.delete(cls);
-    this.#finalized.delete(cls);
-  }
-
-  @ExchangeExpired()
   has(cls: Class): boolean {
     return this.#adapters.has(cls);
   }
 
-  @ExchangeExpired()
   adapter(cls: Class): A {
     if (!this.#adapters.has(cls)!) {
       const adapter = new this.#adapterCls(cls);
@@ -72,7 +49,6 @@ export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<
     return castTo(this.#adapters.get(cls));
   }
 
-  @ExchangeExpired()
   getForRegister(cls: Class, allowFinalized = false): A {
     if (this.#finalized.get(cls) && !allowFinalized) {
       throw new AppError(`Class ${cls.Ⲑid} is already finalized`);
@@ -80,7 +56,6 @@ export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<
     return this.adapter(cls);
   }
 
-  @ExchangeExpired()
   get(cls: Class): Omit<A, RegistrationMethods> {
     if (!this.has(cls)) {
       throw new AppError(`Class ${cls.Ⲑid} is not registered for ${this.#adapterCls.Ⲑid}`);
@@ -88,7 +63,6 @@ export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<
     return this.adapter(cls);
   }
 
-  @ExchangeExpired()
   getOptional(cls: Class): Omit<A, RegistrationMethods> | undefined {
     if (!this.has(cls)) {
       return undefined;
@@ -96,7 +70,6 @@ export class RegistryIndexStore<A extends RegistryAdapter<{}> = RegistryAdapter<
     return this.adapter(cls);
   }
 
-  @ExchangeExpired()
   finalized(cls: Class): boolean {
     return this.#finalized.has(cls);
   }

package/src/types.ts

@@ -1,20 +1,38 @@
+import type { Class } from '@travetto/runtime';
+
+export type RegistrationMethods = `register${string}` | `finalize${string}`;
+
 /**
- * A change event
+ * Interface for registry adapters to implement
  */
-export type ChangeEvent<T> =
-  { type: 'changed', prev: T, curr: T } |
-  { type: 'added', curr: T } |
-  { type: 'removing', prev: T };
+export interface RegistryAdapter<C extends {} = {}> {
+  register(...data: Partial<C>[]): C;
+  finalize?(parent?: C): void;
+  get(): C;
+}
+
+export type RegistryIndexClass = {
+  new(source: unknown): RegistryIndex;
+};
 
 /**
- * Change handler
+ * Simple store interface for registry indexes
  */
-export type ChangeHandler<T> = (e: ChangeEvent<T>) => unknown;
+export interface RegistrySimpleStore {
+  has(cls: Class): boolean;
+  finalize(cls: Class): void;
+  finalized(cls: Class): boolean;
+  getClasses(): Class[];
+};
 
 /**
- * Change source
+ * Registry index definition
+ * @concrete
  */
-export interface ChangeSource<T> {
-  init(): Promise<unknown>;
-  on(callback: ChangeHandler<T>): void;
+export interface RegistryIndex {
+  store: RegistrySimpleStore;
+  finalize?(cls: Class): void;
+  onCreate?(cls: Class): void;
+  onChangeSetComplete?(events: Class[]): void;
+  beforeChangeSetComplete?(events: Class[]): void;
 }

package/src/internal/commonjs-loader.ts

@@ -1,88 +0,0 @@
-import { Module } from 'node:module';
-
-import { path } from '@travetto/manifest';
-import { Runtime, RuntimeIndex } from '@travetto/runtime';
-
-import { RetargettingProxy } from '../proxy.ts';
-
-declare module 'module' {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  function _resolveFilename(req: string, parent: typeof Module): string;
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  function _load(req: string, parent: typeof Module): unknown;
-}
-
-type ModuleLoader = typeof Module['_load'];
-type ModuleProxy = <T>(file: string, mod?: T) => (T | undefined);
-
-const moduleLoad: ModuleLoader = Module._load.bind(Module);
-
-/**
- * Dynamic commonjs module loader. Hooks into module loading
- */
-export class DynamicCommonjsLoader {
-
-  /**
-   * Build a module loader
-   */
-  static buildModuleLoader(proxyModuleLoad?: ModuleProxy): ModuleLoader {
-    return (request: string, parent: typeof Module): unknown => {
-      let mod: unknown;
-      try {
-        mod = moduleLoad.apply(null, [request, parent]);
-      } catch (err: unknown) {
-        const name = Module._resolveFilename!(request, parent);
-        if (err instanceof Error && Runtime.dynamic && !name.startsWith('test/')) {
-          const errMsg = err.message;
-          console.debug(`Unable to load ${name}: stubbing out with error proxy.`, errMsg);
-          const e = (): never => { throw new Error(errMsg); };
-          mod = new Proxy({}, { getOwnPropertyDescriptor: e, get: e, has: e });
-        } else {
-          throw err;
-        }
-      }
-
-      const file = Module._resolveFilename!(request, parent);
-      const src = RuntimeIndex.getEntry(file)?.sourceFile;
-      // Only proxy workspace modules
-      if (src && RuntimeIndex.getModuleFromSource(src)?.workspace) {
-        return proxyModuleLoad ? proxyModuleLoad(file, mod) : mod;
-      } else {
-        return mod;
-      }
-    };
-  }
-
-  #loader: ModuleLoader;
-  #modules = new Map<string, RetargettingProxy<unknown>>();
-
-  #proxyModule<T>(file: string, mod?: T): T | undefined {
-    if (!this.#modules.has(file)) {
-      this.#modules.set(file, new RetargettingProxy<T>(mod!));
-    } else {
-      this.#modules.get(file)!.setTarget(mod);
-    }
-    return this.#modules.get(file)!.get<T>();
-  }
-
-  async init(): Promise<void> {
-    this.#loader = DynamicCommonjsLoader.buildModuleLoader((file, mod) => this.#proxyModule(file, mod));
-  }
-
-  async unload(file: string): Promise<void> {
-    const native = path.toNative(file);
-    if (native in require.cache) {
-      delete require.cache[native]; // Remove require cached element
-    }
-    this.#proxyModule(file, null);
-  }
-
-  async load(file: string): Promise<void> {
-    try {
-      Module._load = this.#loader;
-      require(file);
-    } finally {
-      Module._load = moduleLoad;
-    }
-  }
-}

package/src/internal/file-loader.ts

@@ -1,46 +0,0 @@
-import { ManifestModuleUtil } from '@travetto/manifest';
-import { watchCompiler, WatchEvent, Runtime, RuntimeIndex } from '@travetto/runtime';
-
-const VALID_FILE_TYPES = new Set(['js', 'ts']);
-
-const handle = (err: Error): void => {
-  if (err && (err.message ?? '').includes('Cannot find module')) { // Handle module reloading
-    console.error('Cannot find module', { error: err });
-  } else {
-    throw err;
-  }
-};
-
-/**
- * Listens to file changes, and handles loading/unloading as needed (when supported)
- */
-export class DynamicFileLoader {
-
-  static async * listen(): AsyncIterable<WatchEvent> {
-    // TODO: ESM Support?
-    const { DynamicCommonjsLoader } = await import('./commonjs-loader.ts');
-    const loader = new DynamicCommonjsLoader();
-    await loader.init?.();
-
-    process
-      .on('unhandledRejection', handle)
-      .on('uncaughtException', handle);
-
-    // Fire off, and let it run in the bg. Restart on exit
-    for await (const ev of watchCompiler({ restartOnExit: true })) {
-      if (ev.file && RuntimeIndex.hasModule(ev.module) && VALID_FILE_TYPES.has(ManifestModuleUtil.getFileType(ev.file))) {
-        if (ev.action === 'update' || ev.action === 'delete') {
-          await loader.unload(ev.output);
-        }
-        if (ev.action === 'create' || ev.action === 'delete') {
-          RuntimeIndex.reinitForModule(Runtime.main.name);
-        }
-        if (ev.action === 'create' || ev.action === 'update') {
-          await loader.load(ev.output);
-        }
-
-        yield ev;
-      }
-    }
-  }
-}

package/src/proxy.ts

@@ -1,127 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none", "varsIgnorePattern": "^(_.*|[A-Z])$" } ] */
-import { Any, castKey, castTo, classConstruct } from '@travetto/runtime';
-
-const ProxyTargetSymbol = Symbol();
-
-const AsyncGeneratorFunction = Object.getPrototypeOf(async function* () { });
-const GeneratorFunction = Object.getPrototypeOf(function* () { });
-const AsyncFunction = Object.getPrototypeOf(async function () { });
-
-function isFunction(o: unknown): o is Function {
-  const proto = o && Object.getPrototypeOf(o);
-  return proto && (proto === Function.prototype || proto === AsyncFunction || proto === AsyncGeneratorFunction || proto === GeneratorFunction);
-}
-
-/**
- * Handler for for proxying modules while watching
- */
-export class RetargettingHandler<T> implements ProxyHandler<Any> {
-  target: T;
-  constructor(target: T) { this.target = target; }
-
-  isExtensible(target: T): boolean {
-    return !Object.isFrozen(this.target);
-  }
-
-  getOwnPropertyDescriptor(target: T, property: PropertyKey): PropertyDescriptor | undefined {
-    if (property === '__esModule') {
-      return undefined;
-    } else {
-      return Object.getOwnPropertyDescriptor(this.target, property);
-    }
-  }
-
-  preventExtensions(target: T): boolean {
-    return !!Object.preventExtensions(this.target);
-  }
-
-  apply(target: T, thisArg: T, argArray?: unknown[]): unknown {
-    return castTo<Function>(this.target).apply(this.target, argArray);
-  }
-
-  construct(target: T, argArray: unknown[], newTarget?: unknown): object {
-    return classConstruct(castTo(this.target), argArray);
-  }
-
-  setPrototypeOf(target: T, v: unknown): boolean {
-    return Object.setPrototypeOf(this.target, castTo(v));
-  }
-
-  getPrototypeOf(target: T): object | null {
-    return Object.getPrototypeOf(this.target);
-  }
-
-  get(target: T, prop: PropertyKey, receiver: unknown): Any {
-    if (prop === ProxyTargetSymbol) {
-      return this.target;
-    }
-    let result = this.target[castKey<T>(prop)];
-    if (isFunction(result) && !/^class\s/.test(Function.prototype.toString.call(result))) {
-      // Bind class members to class instance instead of proxy propagating
-      result = result.bind(this.target);
-    }
-    return result;
-  }
-
-  has(target: T, prop: PropertyKey): boolean {
-    return castTo<object>(this.target).hasOwnProperty(prop);
-  }
-
-  set(target: T, prop: PropertyKey, value: unknown): boolean {
-    this.target[castKey<T>(prop)] = castTo(value);
-    return true;
-  }
-
-  ownKeys(target: T): (string | symbol)[] {
-    const keys: (string | symbol)[] = [];
-    return keys
-      .concat(Object.getOwnPropertyNames(this.target))
-      .concat(Object.getOwnPropertySymbols(this.target));
-  }
-
-  deleteProperty(target: T, p: PropertyKey): boolean {
-    return delete this.target[castKey<T>(p)];
-  }
-
-  defineProperty(target: T, p: PropertyKey, attributes: PropertyDescriptor): boolean {
-    Object.defineProperty(this.target, p, attributes);
-    return true;
-  }
-}
-
-interface Proxy<T> { }
-
-/**
- * Generate Retargetting Proxy
- */
-export class RetargettingProxy<T> {
-
-  /**
-   * Unwrap proxy
-   */
-  static unwrap<U>(el: U): U {
-    return castTo<{ [ProxyTargetSymbol]: U }>(el)?.[ProxyTargetSymbol] ?? el;
-  }
-
-  #handler: RetargettingHandler<T>;
-  #instance: Proxy<T>;
-
-  constructor(initial: T) {
-    this.#handler = new RetargettingHandler(initial);
-    this.#instance = new Proxy({}, castTo(this.#handler));
-  }
-
-  setTarget(next: T): void {
-    if (next !== this.#handler.target) {
-      this.#handler.target = next;
-    }
-  }
-
-  getTarget(): T {
-    return this.#handler.target;
-  }
-
-  get<V extends T>(): V {
-    return castTo(this.#instance);
-  }
-}

package/src/service/registry.ts

@@ -1,166 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { AppError, castTo, Class, Util } from '@travetto/runtime';
-
-import { ClassSource } from '../source/class-source';
-import { ChangeEvent } from '../types';
-import { MethodSource } from '../source/method-source';
-import { RegistryIndex, RegistryIndexClass, EXPIRED_CLASS } from './types';
-
-class $Registry {
-
-  #resolved = false;
-  #initialized?: Promise<unknown>;
-  trace = false;
-  #uid = Util.uuid();
-
-  // Lookups
-  #indexes = new Map<RegistryIndexClass, RegistryIndex>();
-  #indexOrder: RegistryIndexClass[] = [];
-
-  // Eventing
-  #classSource = new ClassSource();
-  #methodSource?: MethodSource;
-  #emitter = new EventEmitter<{ event: [ChangeEvent<Class>] }>();
-
-  #removeItems(classes: Class[]): void {
-    for (const cls of classes) {
-      for (const idx of this.#indexOrder) {
-        this.instance(idx).store.remove(cls);
-      }
-      // Tag expired classes
-      Object.assign(cls, { [EXPIRED_CLASS]: true });
-    }
-  }
-
-  #finalizeItems(classes: Class[]): void {
-    for (const idx of this.#indexOrder) {
-      const inst = this.instance(idx);
-      for (const cls of classes) {
-        if (inst.store.has(cls) && !inst.store.finalized(cls)) {
-          if (inst.finalize) {
-            inst.finalize(cls);
-          } else {
-            inst.store.finalize(cls);
-          }
-        }
-      }
-    }
-  }
-
-  finalizeForIndex(indexCls: RegistryIndexClass): void {
-    const inst = this.instance(indexCls);
-    this.#finalizeItems(inst.store.getClasses());
-  }
-
-  process(events: ChangeEvent<Class>[]): void {
-    this.#finalizeItems(events.filter(ev => 'curr' in ev).map(ev => ev.curr));
-
-    for (const indexCls of this.#indexOrder) { // Visit every index, in order
-      const inst = this.instance(indexCls);
-      const matched = events.filter(e => inst.store.has('curr' in e ? e.curr : e.prev!));
-      if (matched.length) {
-        inst.process(matched);
-      }
-    }
-
-    Util.queueMacroTask().then(() => {
-      this.#removeItems(events.filter(ev => 'prev' in ev).map(ev => ev.prev!));
-    });
-
-    for (const e of events) {
-      this.#emitter.emit('event', e);
-    }
-  }
-
-  /**
-   * Run initialization
-   */
-  async #init(): Promise<void> {
-    try {
-      this.#resolved = false;
-
-      if (this.trace) {
-        console.debug('Initializing', { uid: this.#uid });
-      }
-
-      const added = await this.#classSource.init();
-      this.process(added.map(cls => ({ type: 'added', curr: cls })));
-      this.#classSource.on(e => this.process([e]));
-    } finally {
-      this.#resolved = true;
-    }
-  }
-
-  /**
-   * Verify initialized state
-   */
-  verifyInitialized(): void {
-    if (!this.#resolved) {
-      throw new AppError('Registry not initialized, call init() first');
-    }
-  }
-
-  /**
-   * Register a new index
-   */
-  registerIndex<T extends RegistryIndexClass>(indexCls: T): InstanceType<T> {
-    if (!this.#indexes.has(indexCls)) {
-      this.#indexes.set(indexCls, new indexCls());
-      this.#indexOrder.push(indexCls);
-    }
-    return castTo(this.#indexes.get(indexCls));
-  }
-
-  /**
-   * Initialize, with a built-in latch to prevent concurrent initializations
-   */
-  async init(): Promise<unknown> {
-    if (this.trace && this.#initialized) {
-      console.trace('Trying to re-initialize', { uid: this.#uid, initialized: !!this.#initialized });
-    }
-    return this.#initialized ??= this.#init();
-  }
-
-  instance<T extends RegistryIndexClass>(indexCls: T): InstanceType<T> {
-    return castTo(this.#indexes.get(indexCls));
-  }
-
-  /**
-   * Listen for changes
-   */
-  onClassChange(handler: (event: ChangeEvent<Class>) => void, matches?: RegistryIndexClass): void {
-    if (!matches) {
-      this.#emitter.on('event', handler);
-    } else {
-      const inst = this.instance(matches);
-      this.#emitter.on('event', (event) => {
-        if (inst.store.has('curr' in event ? event.curr : event.prev!)) {
-          handler(event);
-        }
-      });
-    }
-  }
-
-  onNonClassChanges(handler: (file: string) => void): void {
-    this.#classSource.onNonClassChanges(handler);
-  }
-
-  onMethodChange(
-    handler: (event: ChangeEvent<[Class, Function]>) => void,
-    matches?: RegistryIndexClass,
-  ): void {
-    const src = this.#methodSource ??= new MethodSource(this.#classSource);
-    if (!matches) {
-      src.on(handler);
-    } else {
-      const inst = this.instance(matches);
-      src.on((event) => {
-        if (inst.store.has('curr' in event ? event.curr[0] : event.prev[0])) {
-          handler(event);
-        }
-      });
-    }
-  }
-}
-
-export const Registry = new $Registry();

package/src/service/types.ts

@@ -1,40 +0,0 @@
-import { Class } from '@travetto/runtime';
-import { ChangeEvent } from '../types';
-
-export type RegistrationMethods = `register${string}` | `finalize${string}`;
-
-export const EXPIRED_CLASS = Symbol();
-
-/**
- * Interface for registry adapters to implement
- */
-export interface RegistryAdapter<C extends {} = {}> {
-  register(...data: Partial<C>[]): C;
-  finalize?(parent?: C): void;
-  get(): C;
-}
-
-export type RegistryIndexClass = {
-  new(): RegistryIndex;
-};
-
-/**
- * Simple store interface for registry indexes
- */
-export interface RegistrySimpleStore {
-  has(cls: Class): boolean;
-  finalize(cls: Class): void;
-  finalized(cls: Class): boolean;
-  remove(cls: Class): void;
-  getClasses(): Class[];
-};
-
-/**
- * Registry index definition
- * @concrete
- */
-export interface RegistryIndex {
-  store: RegistrySimpleStore;
-  process(events: ChangeEvent<Class>[]): void;
-  finalize?(cls: Class): void;
-}

package/src/source/class-source.ts

@@ -1,196 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { Class, Env, Runtime, RuntimeIndex, describeFunction, flushPendingFunctions } from '@travetto/runtime';
-
-import { DynamicFileLoader } from '../internal/file-loader.ts';
-import { ChangeSource, ChangeEvent, ChangeHandler } from '../types.ts';
-
-function isClass(cls: Function): cls is Class {
-  return !!describeFunction(cls).class;
-}
-
-/**
- * A class change source. Meant to be hooked into the
- * compiler as a way to listen to changes via the compiler
- * watching.
- */
-export class ClassSource implements ChangeSource<Class> {
-
-  #classes = new Map<string, Map<string, Class>>();
-  #emitter = new EventEmitter<{
-    change: [ChangeEvent<Class>];
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    'unchanged-import': [string];
-  }>();
-  #listening: Promise<void> | undefined;
-
-  /**
-   * Are we in a mode that should have enhanced debug info
-   */
-  trace = Env.DEBUG.val?.includes('@travetto/registry');
-
-  /**
-   * Flush classes
-   */
-  #flush(): Class[] {
-    const flushed = flushPendingFunctions().filter(isClass);
-    for (const cls of flushed) {
-      const src = Runtime.getSourceFile(cls);
-      if (!this.#classes.has(src)) {
-        this.#classes.set(src, new Map());
-      }
-      this.#classes.get(src)!.set(cls.Ⲑid, cls);
-      this.emit({ type: 'added', curr: cls });
-    }
-    return flushed;
-  }
-
-  #removeFile(file: string): void {
-    const data = this.#classes.get(file);
-    if (data) {
-      this.#classes.delete(file);
-      for (const cls of data) {
-        this.emit({ type: 'removing', prev: cls[1] });
-      }
-    }
-  }
-
-  /**
-   * Process changes for a single file, looking for add/remove/update of classes
-   */
-  #handleFileChanges(importFile: string, classes: Class[] = []): number {
-    const next = new Map<string, Class>(classes.map(cls => [cls.Ⲑid, cls] as const));
-    const sourceFile = RuntimeIndex.getSourceFile(importFile);
-
-    let prev = new Map<string, Class>();
-    if (this.#classes.has(sourceFile)) {
-      prev = new Map(this.#classes.get(sourceFile)!.entries());
-    }
-
-    const keys = new Set([...Array.from(prev.keys()), ...Array.from(next.keys())]);
-
-    if (!this.#classes.has(sourceFile)) {
-      this.#classes.set(sourceFile, new Map());
-    }
-
-    let changes = 0;
-
-    // Determine delta based on the various classes (if being added, removed or updated)
-    for (const k of keys) {
-      if (!next.has(k)) {
-        changes += 1;
-        this.emit({ type: 'removing', prev: prev.get(k)! });
-        this.#classes.get(sourceFile)!.delete(k);
-      } else {
-        this.#classes.get(sourceFile)!.set(k, next.get(k)!);
-        if (!prev.has(k)) {
-          changes += 1;
-          this.emit({ type: 'added', curr: next.get(k)! });
-        } else {
-          const prevHash = describeFunction(prev.get(k)!)?.hash;
-          const nextHash = describeFunction(next.get(k)!)?.hash;
-          if (prevHash !== nextHash) {
-            changes += 1;
-            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k)! });
-          }
-        }
-      }
-    }
-    return changes;
-  }
-
-  /**
-   * Process all class changes
-   */
-  #handleChanges(classes: Class[] = []): void {
-    const classesByFile = new Map<string, Class[]>();
-    for (const el of classes) {
-      const imp = Runtime.getImport(el);
-      if (!classesByFile.has(imp)) {
-        classesByFile.set(imp, []);
-      }
-      classesByFile.get(imp)!.push(el);
-    }
-
-    for (const [imp, els] of classesByFile.entries()) {
-      if (!this.#handleFileChanges(imp, els)) {
-        this.#emitter.emit('unchanged-import', imp);
-      }
-    }
-  }
-
-  /**
-   * Emit a change event
-   */
-  emit(e: ChangeEvent<Class>): void {
-    if (this.trace) {
-      console.debug('Emitting change', {
-        type: e.type,
-        curr: (e.type !== 'removing' ? e.curr?.Ⲑid : undefined),
-        prev: (e.type !== 'added' ? e.prev?.Ⲑid : undefined)
-      });
-    }
-    this.#emitter.emit('change', e);
-  }
-
-  /**
-   * Initialize
-   */
-  async init(): Promise<Class[]> {
-    if (Runtime.dynamic && !this.#listening) {
-      this.#listening = (async (): Promise<void> => {
-        for await (const ev of await DynamicFileLoader.listen()) {
-          if (ev.action === 'delete') {
-            this.#removeFile(ev.file); // File no longer exists
-          } else {
-            this.#handleChanges(flushPendingFunctions().filter(isClass));
-          }
-
-          if (ev.action === 'create') {
-            this.#flush();
-          }
-        }
-      })();
-    }
-
-    // Ensure everything is loaded
-    for (const entry of RuntimeIndex.find({
-      module: (m) => {
-        const role = Env.TRV_ROLE.val;
-        return role !== 'test' && // Skip all modules when in test
-          m.roles.includes('std') &&
-          (
-            !Runtime.production || m.prod ||
-            (role === 'doc' && m.roles.includes(role))
-          );
-      },
-      folder: f => f === 'src' || f === '$index'
-    })) {
-      await Runtime.importFrom(entry.import);
-    }
-
-    // Flush all load events
-    return this.#flush();
-  }
-
-  /**
-   * Add callback for change events
-   */
-  on(callback: ChangeHandler<Class>): void {
-    this.#emitter.on('change', callback);
-  }
-
-  /**
-   * Add callback for change events
-   */
-  off(callback: ChangeHandler<Class>): void {
-    this.#emitter.off('change', callback);
-  }
-
-  /**
-   * Add callback for when a import is changed, but emits no class changes
-   */
-  onNonClassChanges(callback: (imp: string) => void): void {
-    this.#emitter.on('unchanged-import', callback);
-  }
-}

package/src/source/method-source.ts

@@ -1,60 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { Class, describeFunction } from '@travetto/runtime';
-
-import { ChangeSource, ChangeEvent, ChangeHandler } from '../types.ts';
-
-/**
- * Change source specific to individual methods of classes.  Useful
- * for method based registries
- */
-export class MethodSource implements ChangeSource<[Class, Function]> {
-
-  #emitter = new EventEmitter();
-
-  /**
-   * Define parent change source, generally will be the class source
-   */
-  constructor(classSource: ChangeSource<Class>) {
-    classSource.on(e => this.onClassEvent(e));
-  }
-
-  async init(): Promise<void> { }
-
-  emit(ev: ChangeEvent<[Class, Function]>): void {
-    this.#emitter.emit('change', ev);
-  }
-
-  /**
-   * On a class being emitted, check methods
-   */
-  onClassEvent(e: ChangeEvent<Class>): void {
-    const next = (e.type !== 'removing' ? describeFunction(e.curr!)?.methods : null) ?? {};
-    const prev = (e.type !== 'added' ? describeFunction(e.prev!)?.methods : null) ?? {};
-
-    /**
-     * Go through each method, comparing hashes.  To see added/removed and changed
-     */
-    for (const k of Object.keys(next)) {
-      if ((!prev[k] || !('prev' in e)) && e.type !== 'removing') {
-        this.emit({ type: 'added', curr: [e.curr!, e.curr!.prototype[k]] });
-      } else if (next[k].hash !== prev[k].hash && e.type === 'changed') {
-        // FIXME: Why is e.prev undefined sometimes?
-        this.emit({ type: 'changed', curr: [e.curr, e.curr.prototype[k]], prev: [e.prev, e.prev.prototype[k]] });
-      } else {
-        // Method Unchanged
-      }
-    }
-
-    for (const k of Object.keys(prev)) {
-      if (!next[k] && e.type !== 'added') {
-        this.emit({ type: 'removing', prev: [e.prev, e.prev.prototype[k]] });
-      }
-    }
-  }
-
-  on(callback: ChangeHandler<[Class, Function]>): this {
-    this.#emitter.on('change', callback);
-    return this;
-  }
-}