@travetto/registry 3.3.4 → 3.4.0-rc.1

package/README.md

@@ -74,7 +74,7 @@ The registry is a [MetadataRegistry](https://github.com/travetto/travetto/tree/m
 ### 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/base/src/internal/file-loader.ts#L24) notifies that a file has been changed, the [RootRegistry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/root.ts#L10) will pick it up, and process it accordingly.
+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 [RootRegistry](https://github.com/travetto/travetto/tree/main/module/registry/src/service/root.ts#L10) 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/registry",
-  "version": "3.3.4",
+  "version": "3.4.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.3.4"
+    "@travetto/base": "^3.4.0-rc.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.3.6",
-    "@travetto/transformer": "^3.3.2"
+    "@travetto/cli": "^3.4.0-rc.2",
+    "@travetto/transformer": "^3.4.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator.ts

@@ -24,7 +24,10 @@ class $PendingRegister {
   /**
    * Clear pending classes
    */
-  flush(): [string, Class[]][] {
+  flush(log?: boolean): [string, Class[]][] {
+    if (log) {
+      console.debug('Pending changes', { changes: this.ordered.map(([, x]) => x.map(y => y.Ⲑid)) });
+    }
     const out = this.ordered.slice(0);
     this.map.clear();
     this.ordered = [];

package/src/internal/commonjs-loader.ts

@@ -0,0 +1,86 @@
+import { Module } from 'module';
+
+import { RootIndex, path } from '@travetto/manifest';
+import { RetargettingProxy, GlobalEnv } from '@travetto/base';
+
+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 && GlobalEnv.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 fileName = Module._resolveFilename!(request, parent);
+      // Only proxy local modules
+      if (RootIndex.getModuleFromSource(fileName)?.local) {
+        return proxyModuleLoad ? proxyModuleLoad(fileName, 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);
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return this.#modules.get(file)!.get() as 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

@@ -0,0 +1,72 @@
+import { ManifestModuleUtil, RootIndex } from '@travetto/manifest';
+import { ShutdownManager, CompilerClient } 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>;
+}
+
+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[] = [];
+  #loader: ModuleLoader;
+  #initialized = false;
+
+  async dispatch(ev: CompilerWatchEvent): 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);
+    }
+    if (ev.action === 'create' || ev.action === 'update') {
+      await this.#loader.load(ev.output);
+    }
+
+    for (const handler of this.#handlers) {
+      await handler(ev);
+    }
+  }
+
+  onLoadEvent(handler: WatchHandler): void {
+    this.#handlers.push(handler);
+  }
+
+  async init(): Promise<void> {
+    if (this.#initialized) {
+      return;
+    }
+
+    this.#initialized = true;
+
+    // TODO: ESM Support?
+    const { DynamicCommonjsLoader } = await import('./commonjs-loader.js');
+    this.#loader = new DynamicCommonjsLoader();
+
+    await this.#loader.init?.();
+
+    ShutdownManager.onUnhandled(err => {
+      if (err && (err.message ?? '').includes('Cannot find module')) { // Handle module reloading
+        console.error('Cannot find module', { error: err });
+        return true;
+      }
+    }, 0);
+
+
+    // Fire off, and let it run in the bg, restart on exit
+    await new CompilerClient().onFileChange(async ev => {
+      if (ev.file && RootIndex.hasModule(ev.module) && VALID_FILE_TYPES.has(ManifestModuleUtil.getFileType(ev.file))) {
+        await this.dispatch(ev);
+      }
+    }, true);
+  }
+}
+
+export const DynamicFileLoader = new $DynamicFileLoader();

package/src/source/class-source.ts

@@ -1,12 +1,21 @@
 import { EventEmitter } from 'events';
 
-import { WatchEvent, RootIndex } from '@travetto/manifest';
+import { FindConfig, RootIndex } from '@travetto/manifest';
 import { Class, GlobalEnv } from '@travetto/base';
-import { DynamicFileLoader } from '@travetto/base/src/internal/file-loader';
 
+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)
+    ),
+  folder: f => f === 'src' || f === '$index'
+};
+
 /**
  * A class change source. Meant to be hooked into the
  * compiler as a way to listen to changes via the compiler
@@ -81,19 +90,6 @@ export class ClassSource implements ChangeSource<Class> {
     }
   }
 
-  /**
-   * Handle when a file watch event happens
-   */
-  async onLoadEvent(ev: WatchEvent): Promise<void> {
-    console.debug('Pending changes', { changes: PendingRegister.ordered.map(([, x]) => x.map(y => y.Ⲑid)) });
-    for (const [file, classes] of PendingRegister.flush()) {
-      this.#handleFileChanges(file, classes);
-    }
-    if (ev.action === 'create') {
-      this.#flush();
-    }
-  }
-
   /**
    * Emit a change event
    */
@@ -107,12 +103,21 @@ export class ClassSource implements ChangeSource<Class> {
    */
   async init(): Promise<void> {
     if (GlobalEnv.dynamic) {
-      DynamicFileLoader.onLoadEvent(ev => this.onLoadEvent(ev));
+      DynamicFileLoader.onLoadEvent(ev => {
+        for (const [file, classes] of PendingRegister.flush(true)) {
+          this.#handleFileChanges(file, classes);
+        }
+        if (ev.action === 'create') {
+          this.#flush();
+        }
+      });
       await DynamicFileLoader.init();
     }
 
     // Ensure everything is loaded
-    await RootIndex.loadSource();
+    for (const mod of RootIndex.find(moduleFindConfig)) {
+      await import(mod.import);
+    }
 
     // Flush all load events
     this.#flush();

package/support/transformer.register.ts

@@ -16,11 +16,10 @@ export class RegisterTransformer {
    */
   @AfterClass()
   static registerClass(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (state.importName === REGISTER_MOD ||
-      (
-        state.importName.startsWith(BASE_MOD_SRC) ||
-        state.importName.startsWith(MANIFEST_MOD)
-      )
+    if (
+      state.importName === REGISTER_MOD ||
+      state.importName.startsWith(BASE_MOD_SRC) ||
+      state.importName.startsWith(MANIFEST_MOD)
     ) {  // Cannot process self
       return node;
     }