feat(tegg): load modules through loader fs

Author: killagu

tegg/core/loader/package.json

@@ -42,10 +42,11 @@
   },
   "dependencies": {
     "@eggjs/core-decorator": "workspace:*",
+    "@eggjs/loader-fs": "workspace:*",
     "@eggjs/metadata": "workspace:*",
     "@eggjs/tegg-types": "workspace:*",
     "@eggjs/typings": "workspace:*",
-    "globby": "catalog:",
+    "@eggjs/utils": "workspace:*",
     "is-type-of": "catalog:"
   },
   "devDependencies": {

tegg/core/loader/src/LoaderFactory.ts

@@ -1,4 +1,5 @@
 import { PrototypeUtil } from '@eggjs/core-decorator';
+import { type LoaderFS } from '@eggjs/loader-fs';
 import type { ModuleDescriptor } from '@eggjs/metadata';
 import {
   EggLoadUnitType,
@@ -8,7 +9,11 @@ import {
   type ModuleReference,
 } from '@eggjs/tegg-types';
 
-export type LoaderCreator = (unitPath: string) => Loader;
+export interface LoaderOptions {
+  loaderFS?: LoaderFS;
+}
+
+export type LoaderCreator = (unitPath: string, options?: LoaderOptions) => Loader;
 
 export interface ManifestModuleReference {
   name: string;
@@ -40,12 +45,12 @@ export interface LoadAppManifest {
 export class LoaderFactory {
   private static loaderCreatorMap: Map<EggLoadUnitTypeLike, LoaderCreator> = new Map();
 
-  static createLoader(unitPath: string, type: EggLoadUnitTypeLike): Loader {
+  static createLoader(unitPath: string, type: EggLoadUnitTypeLike, options?: LoaderOptions): Loader {
     const creator = this.loaderCreatorMap.get(type);
     if (!creator) {
       throw new Error(`not find creator for loader type ${type}`);
     }
-    return creator(unitPath);
+    return creator(unitPath, options);
   }
 
   static registerLoader(type: EggLoadUnitTypeLike, creator: LoaderCreator): void {
@@ -55,6 +60,7 @@ export class LoaderFactory {
   static async loadApp(
     moduleReferences: readonly ModuleReference[],
     manifest?: LoadAppManifest,
+    options?: LoaderOptions,
   ): Promise<ModuleDescriptor[]> {
     const result: ModuleDescriptor[] = [];
     const multiInstanceClazzList: EggProtoImplClass[] = [];
@@ -79,9 +85,9 @@ export class LoaderFactory {
 
       let loader: Loader;
       if (manifestDesc && ModuleLoaderClass && loaderType === EggLoadUnitType.MODULE) {
-        loader = new ModuleLoaderClass(moduleReference.path, manifestDesc.decoratedFiles);
+        loader = new ModuleLoaderClass(moduleReference.path, manifestDesc.decoratedFiles, options?.loaderFS);
       } else {
-        loader = LoaderFactory.createLoader(moduleReference.path, loaderType);
+        loader = LoaderFactory.createLoader(moduleReference.path, loaderType, options);
       }
 
       const res: ModuleDescriptor = {

tegg/core/loader/src/LoaderUtil.ts

@@ -4,6 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { PrototypeUtil } from '@eggjs/core-decorator';
 import type { EggProtoImplClass } from '@eggjs/tegg-types';
 import type {} from '@eggjs/typings/global';
+import { importModule } from '@eggjs/utils';
 import { isClass } from 'is-type-of';
 
 // Guard against poorly mocked module constructors.
@@ -79,13 +80,11 @@ export class LoaderUtil {
       throw createLoadError(originalFilePath, e);
     }
     if (exports == null) {
-      if (process.platform === 'win32') {
-        // convert to file:// url
-        // avoid windows path issue: Only URLs with a scheme in: file, data, and node are supported by the default ESM loader. On Windows, absolute paths must be valid file:// URLs. Received protocol 'd:'
-        filePath = pathToFileURL(filePath).toString();
-      }
       try {
-        exports = await import(filePath);
+        exports =
+          globalThis.__EGG_BUNDLE_MODULE_LOADER__ === undefined
+            ? await importModule(filePath, { importDefaultOnly: false })
+            : await importFallback(filePath);
       } catch (e: unknown) {
         throw createLoadError(filePath, e);
       }
@@ -108,3 +107,12 @@ export class LoaderUtil {
     return clazzList;
   }
 }
+
+async function importFallback(filePath: string): Promise<unknown> {
+  if (process.platform === 'win32') {
+    // convert to file:// url
+    // avoid windows path issue: Only URLs with a scheme in: file, data, and node are supported by the default ESM loader. On Windows, absolute paths must be valid file:// URLs. Received protocol 'd:'
+    filePath = pathToFileURL(filePath).toString();
+  }
+  return await import(filePath);
+}

tegg/core/loader/src/impl/ModuleLoader.ts

@@ -1,8 +1,8 @@
 import path from 'node:path';
 import { debuglog } from 'node:util';
 
+import { RealLoaderFS, type LoaderFS } from '@eggjs/loader-fs';
 import type { EggProtoImplClass, Loader } from '@eggjs/tegg-types';
-import globby from 'globby';
 
 import { LoaderFactory } from '../LoaderFactory.ts';
 import { LoaderUtil } from '../LoaderUtil.ts';
@@ -11,13 +11,15 @@ const debug = debuglog('egg/tegg/loader/impl/ModuleLoader');
 
 export class ModuleLoader implements Loader {
   private readonly moduleDir: string;
+  private readonly loaderFS: LoaderFS;
   private protoClazzList: EggProtoImplClass[];
   /** Pre-computed file list from manifest (only decorated files) */
   private readonly precomputedFiles?: string[];
 
-  constructor(moduleDir: string, precomputedFiles?: string[]) {
+  constructor(moduleDir: string, precomputedFiles?: string[], loaderFS: LoaderFS = new RealLoaderFS()) {
     this.moduleDir = moduleDir;
     this.precomputedFiles = precomputedFiles;
+    this.loaderFS = loaderFS;
   }
 
   async load(): Promise<EggProtoImplClass[]> {
@@ -33,7 +35,7 @@ export class ModuleLoader implements Loader {
       debug('load from manifest, files: %o, moduleDir: %o', files, this.moduleDir);
     } else {
       const filePattern = LoaderUtil.filePattern();
-      files = await globby(filePattern, { cwd: this.moduleDir });
+      files = this.loaderFS.glob(filePattern, { cwd: this.moduleDir });
       debug('load files: %o, filePattern: %o, moduleDir: %o', files, filePattern, this.moduleDir);
     }
     for (const file of files) {
@@ -47,8 +49,8 @@ export class ModuleLoader implements Loader {
     return this.protoClazzList;
   }
 
-  static createModuleLoader(path: string): ModuleLoader {
-    return new ModuleLoader(path);
+  static createModuleLoader(path: string, options?: { loaderFS?: LoaderFS }): ModuleLoader {
+    return new ModuleLoader(path, undefined, options?.loaderFS);
   }
 }
 

tegg/core/loader/test/LoaderFactoryManifest.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import path from 'node:path';
 
+import { RealLoaderFS, type LoaderFSGlobOptions } from '@eggjs/loader-fs';
 import { ModuleDescriptorDumper } from '@eggjs/metadata';
 import { describe, it } from 'vitest';
 
@@ -87,4 +88,23 @@ describe('core/loader/test/LoaderFactoryManifest.test.ts', () => {
       assert.deepStrictEqual(secondNames, firstNames);
     }
   });
+
+  it('should pass loaderFS to module loaders', async () => {
+    const loaderFS = new RecordingLoaderFS();
+
+    const descriptors = await LoaderFactory.loadApp([moduleRef], undefined, { loaderFS });
+
+    assert.equal(descriptors.length, 1);
+    assert(descriptors[0].clazzList.length > 0);
+    assert.deepEqual(loaderFS.globCalls, [{ cwd: repoModulePath }]);
+  });
 });
+
+class RecordingLoaderFS extends RealLoaderFS {
+  readonly globCalls: Array<{ cwd: string | undefined }> = [];
+
+  glob(patterns: string | string[], options?: LoaderFSGlobOptions): string[] {
+    this.globCalls.push({ cwd: options?.cwd ? String(options.cwd) : undefined });
+    return super.glob(patterns, options);
+  }
+}

tegg/core/loader/test/ModuleLoaderManifest.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import path from 'node:path';
 
+import { RealLoaderFS, type LoaderFSGlobOptions } from '@eggjs/loader-fs';
 import { EggLoadUnitType } from '@eggjs/metadata';
 import { describe, it } from 'vitest';
 
@@ -49,4 +50,23 @@ describe('core/loader/test/ModuleLoaderManifest.test.ts', () => {
     const second = await loader.load();
     assert.strictEqual(first, second);
   });
+
+  it('should use loaderFS for file discovery', async () => {
+    const loaderFS = new RecordingLoaderFS();
+    const loader = new ModuleLoader(repoModulePath, undefined, loaderFS);
+
+    const prototypes = await loader.load();
+
+    assert.equal(prototypes.length, 4);
+    assert.deepEqual(loaderFS.globCalls, [{ cwd: repoModulePath }]);
+  });
 });
+
+class RecordingLoaderFS extends RealLoaderFS {
+  readonly globCalls: Array<{ cwd: string | undefined }> = [];
+
+  glob(patterns: string | string[], options?: LoaderFSGlobOptions): string[] {
+    this.globCalls.push({ cwd: options?.cwd ? String(options.cwd) : undefined });
+    return super.glob(patterns, options);
+  }
+}

tegg/plugin/controller/package.json

@@ -96,6 +96,7 @@
     "@eggjs/controller-decorator": "workspace:*",
     "@eggjs/core-decorator": "workspace:*",
     "@eggjs/lifecycle": "workspace:*",
+    "@eggjs/loader-fs": "workspace:*",
     "@eggjs/metadata": "workspace:*",
     "@eggjs/module-common": "workspace:*",
     "@eggjs/router": "workspace:*",
@@ -107,7 +108,6 @@
     "await-event": "catalog:",
     "content-type": "catalog:",
     "egg-errors": "catalog:",
-    "globby": "catalog:",
     "koa-compose": "catalog:",
     "path-to-regexp": "catalog:path-to-regexp1",
     "raw-body": "^2.5.2",

tegg/plugin/controller/src/app.ts

@@ -52,7 +52,10 @@ export default class ControllerAppBootHook implements ILifecycleBoot {
     this.app.eggPrototypeLifecycleUtil.registerLifecycle(this.controllerPrototypeHook);
     this.app.eggObjectFactory.registerEggObjectCreateMethod(AgentControllerProto, AgentControllerObject.createObject);
     this.app.loaderFactory.registerLoader(CONTROLLER_LOAD_UNIT, (unitPath) => {
-      return new EggControllerLoader(unitPath);
+      return new EggControllerLoader(unitPath, {
+        loaderFS: this.app.loader.loaderFS,
+        manifest: this.app.loader.manifest,
+      });
     });
     this.controllerRegisterFactory.registerControllerRegister(ControllerType.HTTP, HTTPControllerRegister.create);
     this.app.loadUnitFactory.registerLoadUnitCreator(

tegg/plugin/controller/src/lib/EggControllerLoader.ts

@@ -1,24 +1,36 @@
 import path from 'node:path';
 
 import type { EggProtoImplClass } from '@eggjs/core-decorator';
+import { RealLoaderFS, type LoaderFS } from '@eggjs/loader-fs';
 import { LoaderUtil } from '@eggjs/tegg-loader';
 import type { Loader } from '@eggjs/tegg-types';
-import globby from 'globby';
+
+interface FileDiscoveryManifest {
+  globFiles?: (directory: string, fallback: () => string[]) => string[];
+}
 
 export class EggControllerLoader implements Loader {
   private readonly controllerDir: string;
+  private readonly loaderFS: LoaderFS;
+  private readonly manifest?: FileDiscoveryManifest;
 
-  constructor(controllerDir: string) {
+  constructor(controllerDir: string, options?: { loaderFS?: LoaderFS; manifest?: FileDiscoveryManifest }) {
     this.controllerDir = controllerDir;
+    this.loaderFS = options?.loaderFS ?? new RealLoaderFS();
+    this.manifest = options?.manifest;
   }
 
   async load(): Promise<EggProtoImplClass[]> {
     const filePattern = LoaderUtil.filePattern();
     let files: string[];
     try {
-      const httpControllers = (await globby(filePattern, { cwd: this.controllerDir })).map((file) =>
-        path.join(this.controllerDir, file),
-      );
+      const discovered =
+        typeof this.manifest?.globFiles === 'function'
+          ? this.manifest.globFiles(this.controllerDir, () =>
+              this.loaderFS.glob(filePattern, { cwd: this.controllerDir }),
+            )
+          : this.loaderFS.glob(filePattern, { cwd: this.controllerDir });
+      const httpControllers = discovered.map((file) => path.join(this.controllerDir, file));
       files = httpControllers;
     } catch {
       files = [];

tegg/plugin/controller/test/lib/EggControllerLoader.test.ts

@@ -1,3 +1,4 @@
+import { RealLoaderFS, type LoaderFSGlobOptions } from '@eggjs/loader-fs';
 import { ControllerMetadataUtil } from '@eggjs/tegg';
 import { describe, it, expect } from 'vitest';
 
@@ -15,4 +16,51 @@ describe('plugin/controller/test/lib/EggModuleLoader.test.ts', () => {
     const metadata = ControllerMetadataUtil.getControllerMetadata(AppController);
     expect(metadata).toBeDefined();
   });
+
+  it('should use loaderFS for controller discovery', async () => {
+    const controllerDir = getFixtures('apps/controller-app/app/controller');
+    const loaderFS = new RecordingLoaderFS();
+    const loader = new EggControllerLoader(controllerDir, { loaderFS });
+
+    const classes = await loader.load();
+
+    expect(classes.length).toBe(7);
+    expect(loaderFS.globCalls).toEqual([{ cwd: controllerDir }]);
+  });
+
+  it('should use manifest-backed controller file discovery when available', async () => {
+    const controllerDir = getFixtures('apps/controller-app/app/controller');
+    const loaderFS = new RecordingLoaderFS();
+    const manifest = {
+      globFiles() {
+        return ['AppController.ts'];
+      },
+    };
+    const loader = new EggControllerLoader(controllerDir, { loaderFS, manifest });
+
+    const classes = await loader.load();
+
+    expect(classes.map((clazz) => clazz.name)).toEqual(['AppController']);
+    expect(loaderFS.globCalls).toEqual([]);
+  });
+
+  it('should fall back to loaderFS when manifest has no globFiles method', async () => {
+    const controllerDir = getFixtures('apps/controller-app/app/controller');
+    const loaderFS = new RecordingLoaderFS();
+    const loader = new EggControllerLoader(controllerDir, { loaderFS, manifest: {} });
+
+    const classes = await loader.load();
+
+    expect(classes.length).toBe(7);
+    expect(loaderFS.globCalls).toEqual([{ cwd: controllerDir }]);
+  });
 });
+
+class RecordingLoaderFS extends RealLoaderFS {
+  readonly globCalls: Array<{ cwd: string | undefined }> = [];
+
+  glob(patterns: string | string[], options?: LoaderFSGlobOptions): string[] {
+    this.globCalls.push({ cwd: options?.cwd ? String(options.cwd) : undefined });
+    return super.glob(patterns, options);
+  }
+}