@travetto/registry 3.4.2 → 4.0.0-rc.1

package/README.md

@@ -112,8 +112,8 @@ As mentioned in [Manifest](https://github.com/travetto/travetto/tree/main/module
           changes += 1;
           this.emit({ type: 'added', curr: next.get(k)! });
         } else {
-          const prevMeta = RootIndex.getFunctionMetadataFromClass(prev.get(k));
-          const nextMeta = RootIndex.getFunctionMetadataFromClass(next.get(k));
+          const prevMeta = RuntimeIndex.getFunctionMetadataFromClass(prev.get(k));
+          const nextMeta = RuntimeIndex.getFunctionMetadataFromClass(next.get(k));
           if (prevMeta?.hash !== nextMeta?.hash) {
             changes += 1;
             this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k) });

package/__index__.ts

@@ -1,6 +1,7 @@
 export * from './src/registry';
 export * from './src/service/metadata';
 export * from './src/service/root';
+export * from './src/proxy';
 export * from './src/registry';
 export * from './src/source/class-source';
 export * from './src/source/method-source';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/registry",
-  "version": "3.4.2",
+  "version": "4.0.0-rc.1",
   "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/base": "^3.4.2"
+    "@travetto/base": "^4.0.0-rc.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.4.7",
-    "@travetto/transformer": "^3.4.2"
+    "@travetto/cli": "^4.0.0-rc.1",
+    "@travetto/transformer": "^4.0.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator.ts

@@ -1,5 +1,5 @@
 import { Class } from '@travetto/base';
-import { RootIndex } from '@travetto/manifest';
+import { RuntimeIndex } from '@travetto/manifest';
 
 /**
  * Register a class as pending
@@ -12,7 +12,7 @@ class $PendingRegister {
    * Register class as pending
    */
   add(cls: Class): void {
-    const src = RootIndex.getFunctionMetadata(cls)!.source;
+    const src = RuntimeIndex.getFunctionMetadata(cls)!.source;
     if (!this.map.has(src)) {
       const sub: Class[] = [];
       this.map.set(src, sub);

package/src/internal/commonjs-loader.ts

@@ -1,7 +1,9 @@
-import { Module } from 'module';
+import { Module } from 'node:module';
 
-import { RootIndex, path } from '@travetto/manifest';
-import { RetargettingProxy, GlobalEnv } from '@travetto/base';
+import { RuntimeIndex, path } from '@travetto/manifest';
+import { Env } from '@travetto/base';
+
+import { RetargettingProxy } from '../proxy';
 
 declare module 'module' {
   // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -30,7 +32,7 @@ export class DynamicCommonjsLoader {
         mod = moduleLoad.apply(null, [request, parent]);
       } catch (err: unknown) {
         const name = Module._resolveFilename!(request, parent);
-        if (err instanceof Error && GlobalEnv.dynamic && !name.startsWith('test/')) {
+        if (err instanceof Error && Env.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); };
@@ -41,8 +43,8 @@ export class DynamicCommonjsLoader {
       }
 
       const fileName = Module._resolveFilename!(request, parent);
-      // Only proxy local modules
-      if (RootIndex.getModuleFromSource(fileName)?.local) {
+      // Only proxy workspace modules
+      if (RuntimeIndex.getModuleFromSource(fileName)?.workspace) {
         return proxyModuleLoad ? proxyModuleLoad(fileName, mod) : mod;
       } else {
         return mod;

package/src/internal/file-loader.ts

@@ -1,30 +1,30 @@
-import { ManifestModuleUtil, RootIndex } from '@travetto/manifest';
-import { ShutdownManager, CompilerClient } from '@travetto/base';
+import { ManifestModuleUtil, RuntimeIndex, RuntimeContext } from '@travetto/manifest';
+import { watchCompiler, FullWatchEvent, WatchEvent } from '@travetto/base';
 
-type WatchHandler = Parameters<CompilerClient['onFileChange']>[0];
-type CompilerWatchEvent = Parameters<WatchHandler>[0];
 interface ModuleLoader {
   init?(): Promise<void>;
   load(file: string): Promise<void>;
   unload(file: string): Promise<void>;
 }
 
+type Handler = (ev: WatchEvent) => unknown;
+
 const VALID_FILE_TYPES = new Set(['js', 'ts']);
 
 /**
  * Listens to file changes, and provides a unified interface for watching file changes, reloading files as needed
  */
 class $DynamicFileLoader {
-  #handlers: WatchHandler[] = [];
+  #handlers: Handler[] = [];
   #loader: ModuleLoader;
   #initialized = false;
 
-  async dispatch(ev: CompilerWatchEvent): Promise<void> {
+  async dispatch(ev: FullWatchEvent): Promise<void> {
     if (ev.action === 'update' || ev.action === 'delete') {
       await this.#loader.unload(ev.output);
     }
     if (ev.action === 'create' || ev.action === 'delete') {
-      RootIndex.reinitForModule(RootIndex.mainModuleName);
+      RuntimeIndex.reinitForModule(RuntimeContext.main.name);
     }
     if (ev.action === 'create' || ev.action === 'update') {
       await this.#loader.load(ev.output);
@@ -35,7 +35,7 @@ class $DynamicFileLoader {
     }
   }
 
-  onLoadEvent(handler: WatchHandler): void {
+  onLoadEvent(handler: Handler): void {
     this.#handlers.push(handler);
   }
 
@@ -52,20 +52,26 @@ class $DynamicFileLoader {
 
     await this.#loader.init?.();
 
-    ShutdownManager.onUnhandled(err => {
+    const handle = (err: Error): void => {
       if (err && (err.message ?? '').includes('Cannot find module')) { // Handle module reloading
         console.error('Cannot find module', { error: err });
-        return true;
+      } else {
+        throw err;
       }
-    }, 0);
+    };
 
+    process
+      .on('unhandledRejection', handle)
+      .on('uncaughtException', handle);
 
     // Fire off, and let it run in the bg. Restart on exit
-    new CompilerClient().onFileChange(async ev => {
-      if (ev.file && RootIndex.hasModule(ev.module) && VALID_FILE_TYPES.has(ManifestModuleUtil.getFileType(ev.file))) {
-        await this.dispatch(ev);
+    (async (): Promise<void> => {
+      for await (const ev of watchCompiler<FullWatchEvent>({ restartOnExit: true })) {
+        if (ev.file && RuntimeIndex.hasModule(ev.module) && VALID_FILE_TYPES.has(ManifestModuleUtil.getFileType(ev.file))) {
+          await this.dispatch(ev);
+        }
       }
-    }, true);
+    })();
   }
 }
 

package/src/proxy.ts

@@ -0,0 +1,137 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type ConcreteClass<T = any> = new (...args: any[]) => T;
+const ProxyTargetⲐ = Symbol.for('@travetto/base:proxy-target');
+
+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
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class RetargettingHandler<T> implements ProxyHandler<any> {
+  constructor(public target: T) { }
+
+  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 {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return (this.target as unknown as Function).apply(this.target, argArray);
+  }
+
+  construct(target: T, argArray: unknown[], newTarget?: unknown): object {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return new (this.target as unknown as ConcreteClass)(...argArray);
+  }
+
+  setPrototypeOf(target: T, v: unknown): boolean {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return Object.setPrototypeOf(this.target, v as Record<string, unknown>);
+  }
+
+  getPrototypeOf(target: T): object | null {
+    return Object.getPrototypeOf(this.target);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get(target: T, prop: PropertyKey, receiver: unknown): any {
+    if (prop === ProxyTargetⲐ) {
+      return this.target;
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    let ret = this.target[prop as keyof T];
+    if (isFunction(ret) && !/^class\s/.test(Function.prototype.toString.call(ret))) {
+      // Bind class members to class instance instead of proxy propagating
+      ret = ret.bind(this.target);
+    }
+    return ret;
+  }
+
+  has(target: T, prop: PropertyKey): boolean {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return (this.target as Object).hasOwnProperty(prop);
+  }
+
+  set(target: T, prop: PropertyKey, value: unknown): boolean {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+    this.target[prop as keyof T] = value as any;
+    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 {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return delete this.target[p as keyof T];
+  }
+
+  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 {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+    return (el ? ((el as any)[ProxyTargetⲐ] ?? el) : el) as U;
+  }
+
+  #handler: RetargettingHandler<T>;
+  #instance: Proxy<T>;
+
+  constructor(initial: T) {
+    this.#handler = new RetargettingHandler(initial);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    this.#instance = new Proxy({}, this.#handler as ProxyHandler<object>);
+  }
+
+  setTarget(next: T): void {
+    if (next !== this.#handler.target) {
+      this.#handler.target = next;
+    }
+  }
+
+  getTarget(): T {
+    return this.#handler.target;
+  }
+
+  get(): T {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return this.#instance as T;
+  }
+}

package/src/registry.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import { Class } from '@travetto/base';
 import { ChangeSource, ChangeEvent, ChangeHandler } from './types';
 

package/src/service/metadata.ts

@@ -1,4 +1,4 @@
-import { Class, DataUtil } from '@travetto/base';
+import { Class } from '@travetto/base';
 
 import { Registry } from '../registry';
 import { ChangeEvent } from '../types';
@@ -13,7 +13,6 @@ function id(cls: string | Class): string {
 export abstract class MetadataRegistry<C extends { class: Class }, M = unknown, F = Function> extends Registry {
 
   static id = id;
-
   /**
    * Classes pending removal
    */
@@ -142,7 +141,7 @@ export abstract class MetadataRegistry<C extends { class: Class }, M = unknown,
    */
   register(cls: Class, pConfig: Partial<C> = {}): void {
     const conf = this.getOrCreatePending(cls);
-    DataUtil.deepAssign(conf, pConfig);
+    Object.assign(conf, pConfig);
   }
 
   /**
@@ -150,7 +149,7 @@ export abstract class MetadataRegistry<C extends { class: Class }, M = unknown,
    */
   registerField(cls: Class, field: F, pConfig: Partial<M>): void {
     const conf = this.getOrCreatePendingField(cls, field);
-    DataUtil.deepAssign(conf, pConfig);
+    Object.assign(conf, pConfig);
   }
 
   /**

package/src/source/class-source.ts

@@ -1,18 +1,20 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 
-import { FindConfig, RootIndex } from '@travetto/manifest';
-import { Class, GlobalEnv } from '@travetto/base';
+import { FindConfig, RuntimeIndex } from '@travetto/manifest';
+import { Class, Env } from '@travetto/base';
 
 import { DynamicFileLoader } from '../internal/file-loader';
 import { ChangeSource, ChangeEvent, ChangeHandler } from '../types';
 import { PendingRegister } from '../decorator';
 
 const moduleFindConfig: FindConfig = {
-  module: (m) =>
-    m.roles.includes('std') && (
-      GlobalEnv.devMode || m.prod ||
-      (GlobalEnv.envName === 'doc' || GlobalEnv.envName === 'test') && m.roles.includes(GlobalEnv.envName)
-    ),
+  module: (m) => {
+    const role = Env.TRV_ROLE.val;
+    return m.roles.includes('std') && (
+      !Env.production || m.prod ||
+      ((role === 'doc' || role === 'test') && m.roles.includes(role))
+    );
+  },
   folder: f => f === 'src' || f === '$index'
 };
 
@@ -36,7 +38,7 @@ export class ClassSource implements ChangeSource<Class> {
       }
       this.#classes.set(file, new Map());
       for (const cls of classes) {
-        const src = RootIndex.getFunctionMetadata(cls)!.source;
+        const src = RuntimeIndex.getFunctionMetadata(cls)!.source;
         this.#classes.get(src)!.set(cls.Ⲑid, cls);
         this.emit({ type: 'added', curr: cls });
       }
@@ -76,8 +78,8 @@ export class ClassSource implements ChangeSource<Class> {
           changes += 1;
           this.emit({ type: 'added', curr: next.get(k)! });
         } else {
-          const prevMeta = RootIndex.getFunctionMetadataFromClass(prev.get(k));
-          const nextMeta = RootIndex.getFunctionMetadataFromClass(next.get(k));
+          const prevMeta = RuntimeIndex.getFunctionMetadataFromClass(prev.get(k));
+          const nextMeta = RuntimeIndex.getFunctionMetadataFromClass(next.get(k));
           if (prevMeta?.hash !== nextMeta?.hash) {
             changes += 1;
             this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k) });
@@ -102,7 +104,7 @@ export class ClassSource implements ChangeSource<Class> {
    * Initialize
    */
   async init(): Promise<void> {
-    if (GlobalEnv.dynamic) {
+    if (Env.dynamic) {
       DynamicFileLoader.onLoadEvent(ev => {
         for (const [file, classes] of PendingRegister.flush(true)) {
           this.#handleFileChanges(file, classes);
@@ -115,7 +117,7 @@ export class ClassSource implements ChangeSource<Class> {
     }
 
     // Ensure everything is loaded
-    for (const mod of RootIndex.find(moduleFindConfig)) {
+    for (const mod of RuntimeIndex.find(moduleFindConfig)) {
       await import(mod.import);
     }
 

package/src/source/method-source.ts

@@ -1,7 +1,7 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 
 import { Class } from '@travetto/base';
-import { RootIndex } from '@travetto/manifest';
+import { RuntimeIndex } from '@travetto/manifest';
 
 import { ChangeSource, ChangeEvent, ChangeHandler } from '../types';
 
@@ -30,8 +30,8 @@ export class MethodSource implements ChangeSource<[Class, Function]> {
    * On a class being emitted, check methods
    */
   onClassEvent(e: ChangeEvent<Class>): void {
-    const next = RootIndex.getFunctionMetadataFromClass(e.curr!)?.methods ?? {};
-    const prev = RootIndex.getFunctionMetadataFromClass(e.prev!)?.methods ?? {};
+    const next = RuntimeIndex.getFunctionMetadataFromClass(e.curr!)?.methods ?? {};
+    const prev = RuntimeIndex.getFunctionMetadataFromClass(e.prev!)?.methods ?? {};
 
     /**
      * Go through each method, comparing hashes.  To see added/removed and changed