feat(tegg): declarative module plugin mechanism

tegg/core/aop-decorator/src/CrosscutAdviceFactory.ts

@@ -1,9 +1,11 @@
 import assert from 'node:assert';
 
+import { InnerObjectProto } from '@eggjs/core-decorator';
 import type { EggProtoImplClass, IAdvice, AdviceInfo } from '@eggjs/tegg-types';
 
 import { CrosscutInfoUtil } from './util/index.ts';
 
+@InnerObjectProto()
 export class CrosscutAdviceFactory {
   private readonly crosscutAdviceClazzList: Array<EggProtoImplClass<IAdvice>> = [];
 

tegg/core/aop-runtime/package.json

@@ -44,6 +44,7 @@
   "dependencies": {
     "@eggjs/aop-decorator": "workspace:*",
     "@eggjs/core-decorator": "workspace:*",
+    "@eggjs/lifecycle": "workspace:*",
     "@eggjs/metadata": "workspace:*",
     "@eggjs/tegg-common-util": "workspace:*",
     "@eggjs/tegg-runtime": "workspace:*",
@@ -59,8 +60,5 @@
   },
   "engines": {
     "node": ">=22.18.0"
-  },
-  "eggModule": {
-    "name": "teggAopRuntime"
   }
 }

tegg/core/aop-runtime/src/AopContextAdviceRegistry.ts

@@ -0,0 +1,27 @@
+import { InnerObjectProto } from '@eggjs/core-decorator';
+import { ObjectInitType } from '@eggjs/tegg-types';
+import type { EggPrototype } from '@eggjs/tegg-types';
+
+export interface ProtoToCreate {
+  name: string;
+  proto: EggPrototype;
+}
+
+@InnerObjectProto()
+export class AopContextAdviceRegistry {
+  readonly #requestProtoList: ProtoToCreate[] = [];
+
+  addAdvice(name: string, proto: EggPrototype): void {
+    if (proto.initType !== ObjectInitType.CONTEXT) {
+      return;
+    }
+    if (this.#requestProtoList.some((t) => t.name === name && t.proto === proto)) {
+      return;
+    }
+    this.#requestProtoList.push({ name, proto });
+  }
+
+  getRequestProtos(): readonly ProtoToCreate[] {
+    return this.#requestProtoList;
+  }
+}

tegg/core/aop-runtime/src/AopGraphHookRegistrar.ts

@@ -0,0 +1,27 @@
+import { InnerObjectProto } from '@eggjs/core-decorator';
+import { LifecyclePostInject } from '@eggjs/lifecycle';
+import { GlobalGraph } from '@eggjs/metadata';
+
+import { crossCutGraphHook } from './CrossCutGraphHook.js';
+import { pointCutGraphHook } from './PointCutGraphHook.js';
+
+/**
+ * Registers the AOP graph build hooks declaratively. Instantiated with the
+ * InnerObjectLoadUnit, which both hosts run AFTER the business GlobalGraph is
+ * created and BEFORE build() consumes the hooks — the only valid window.
+ */
+@InnerObjectProto()
+export class AopGraphHookRegistrar {
+  @LifecyclePostInject()
+  protected registerGraphHooks(): void {
+    const globalGraph = GlobalGraph.instance;
+    if (!globalGraph) {
+      throw new Error(
+        '[aop-runtime] GlobalGraph must be created before AopGraphHookRegistrar is instantiated, ' +
+          'cross-loadUnit crosscut/pointcut weaving would silently never happen',
+      );
+    }
+    globalGraph.registerBuildHook(crossCutGraphHook);
+    globalGraph.registerBuildHook(pointCutGraphHook);
+  }
+}

tegg/core/aop-runtime/src/EggObjectAopHook.ts

@@ -1,13 +1,14 @@
 import assert from 'node:assert';
 
 import { Aspect } from '@eggjs/aop-decorator';
-import { PrototypeUtil } from '@eggjs/core-decorator';
+import { EggObjectLifecycleProto, PrototypeUtil } from '@eggjs/core-decorator';
 import { EggContainerFactory } from '@eggjs/tegg-runtime';
 import { ASPECT_LIST, InjectType } from '@eggjs/tegg-types';
 import type { EggObject, EggObjectLifeCycleContext, LifecycleHook } from '@eggjs/tegg-types';
 
 import { AspectExecutor } from './AspectExecutor.js';
 
+@EggObjectLifecycleProto()
 export class EggObjectAopHook implements LifecycleHook<EggObjectLifeCycleContext, EggObject> {
   private hijackMethods(obj: any, aspectList: Array<Aspect>) {
     for (const aspect of aspectList) {

tegg/core/aop-runtime/src/EggPrototypeCrossCutHook.ts

@@ -1,13 +1,12 @@
 import { CrosscutAdviceFactory, CrosscutInfoUtil } from '@eggjs/aop-decorator';
+import { EggPrototypeLifecycleProto, Inject } from '@eggjs/core-decorator';
 import type { EggPrototype, EggPrototypeLifecycleContext, LifecycleHook } from '@eggjs/tegg-types';
 
+@EggPrototypeLifecycleProto()
 export class EggPrototypeCrossCutHook implements LifecycleHook<EggPrototypeLifecycleContext, EggPrototype> {
+  @Inject()
   private readonly crosscutAdviceFactory: CrosscutAdviceFactory;
 
-  constructor(crosscutAdviceFactory: CrosscutAdviceFactory) {
-    this.crosscutAdviceFactory = crosscutAdviceFactory;
-  }
-
   async preCreate(ctx: EggPrototypeLifecycleContext): Promise<void> {
     if (CrosscutInfoUtil.isCrosscutAdvice(ctx.clazz)) {
       this.crosscutAdviceFactory.registerCrossAdviceClazz(ctx.clazz);

tegg/core/aop-runtime/src/LoadUnitAopHook.ts

@@ -1,4 +1,5 @@
 import { AspectInfoUtil, AspectMetaBuilder, CrosscutAdviceFactory } from '@eggjs/aop-decorator';
+import { Inject, LoadUnitLifecycleProto } from '@eggjs/core-decorator';
 import { EggPrototypeFactory, TeggError } from '@eggjs/metadata';
 import type {
   EggPrototype,
@@ -8,12 +9,15 @@ import type {
   LoadUnitLifecycleContext,
 } from '@eggjs/tegg-types';
 
+import { AopContextAdviceRegistry } from './AopContextAdviceRegistry.js';
+
+@LoadUnitLifecycleProto()
 export class LoadUnitAopHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  @Inject()
   private readonly crosscutAdviceFactory: CrosscutAdviceFactory;
 
-  constructor(crosscutAdviceFactory: CrosscutAdviceFactory) {
-    this.crosscutAdviceFactory = crosscutAdviceFactory;
-  }
+  @Inject()
+  private readonly aopContextAdviceRegistry: AopContextAdviceRegistry;
 
   async postCreate(_: LoadUnitLifecycleContext, loadUnit: LoadUnit): Promise<void> {
     for (const proto of loadUnit.iterateEggPrototype()) {
@@ -39,6 +43,7 @@ export class LoadUnitAopHook implements LifecycleHook<LoadUnitLifecycleContext,
             qualifiers: [],
             proto: adviceProto as EggPrototype,
           });
+          this.aopContextAdviceRegistry.addAdvice(advice.name, adviceProto as EggPrototype);
         }
       }
     }

tegg/core/aop-runtime/src/index.ts

@@ -1,6 +1,8 @@
+export * from './AopContextAdviceRegistry.js';
 export * from './AspectExecutor.js';
 export * from './CrossCutGraphHook.js';
 export * from './EggObjectAopHook.js';
 export * from './EggPrototypeCrossCutHook.js';
 export * from './LoadUnitAopHook.js';
 export * from './PointCutGraphHook.js';
+export * from './AopGraphHookRegistrar.js';

tegg/core/aop-runtime/test/__snapshots__/index.test.ts.snap

@@ -2,6 +2,8 @@
 
 exports[`should export stable 1`] = `
 {
+  "AopContextAdviceRegistry": [Function],
+  "AopGraphHookRegistrar": [Function],
   "AspectExecutor": [Function],
   "EggObjectAopHook": [Function],
   "EggPrototypeCrossCutHook": [Function],

tegg/core/aop-runtime/test/aop-runtime.test.ts

@@ -13,6 +13,7 @@ import { describe, beforeEach, afterEach, it } from 'vitest';
 import { Hello } from './fixtures/modules/hello_succeed/Hello.js';
 
 import { crossCutGraphHook } from '../src/CrossCutGraphHook.js';
+import { AopContextAdviceRegistry } from '../src/AopContextAdviceRegistry.js';
 import { EggObjectAopHook } from '../src/EggObjectAopHook.js';
 import { EggPrototypeCrossCutHook } from '../src/EggPrototypeCrossCutHook.js';
 import { LoadUnitAopHook } from '../src/LoadUnitAopHook.js';
@@ -22,6 +23,13 @@ import { CallTrace } from './fixtures/modules/hello_cross_cut/CallTrace.js';
 import { crosscutAdviceParams } from './fixtures/modules/hello_cross_cut/HelloCrossCut.js';
 import { pointcutAdviceParams } from './fixtures/modules/hello_point_cut/HelloPointCut.js';
 
+function createLoadUnitAopHook(crosscutAdviceFactory: CrosscutAdviceFactory): LoadUnitAopHook {
+  const loadUnitAopHook = new LoadUnitAopHook();
+  Reflect.set(loadUnitAopHook, 'crosscutAdviceFactory', crosscutAdviceFactory);
+  Reflect.set(loadUnitAopHook, 'aopContextAdviceRegistry', new AopContextAdviceRegistry());
+  return loadUnitAopHook;
+}
+
 describe('test/aop-runtime.test.ts', () => {
   afterEach(() => {
     mock.reset();
@@ -37,15 +45,15 @@ describe('test/aop-runtime.test.ts', () => {
     beforeEach(async () => {
       crosscutAdviceFactory = new CrosscutAdviceFactory();
       eggObjectAopHook = new EggObjectAopHook();
-      loadUnitAopHook = new LoadUnitAopHook(crosscutAdviceFactory);
-      eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook(crosscutAdviceFactory);
+      loadUnitAopHook = createLoadUnitAopHook(crosscutAdviceFactory);
+      eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook();
+      Reflect.set(eggPrototypeCrossCutHook, 'crosscutAdviceFactory', crosscutAdviceFactory);
       EggPrototypeLifecycleUtil.registerLifecycle(eggPrototypeCrossCutHook);
       LoadUnitLifecycleUtil.registerLifecycle(loadUnitAopHook);
       EggObjectLifecycleUtil.registerLifecycle(eggObjectAopHook);
 
       modules = await CoreTestHelper.prepareModules(
         [
-          path.join(__dirname, '..'),
           path.join(__dirname, 'fixtures/modules/hello_succeed'),
           path.join(__dirname, 'fixtures/modules/hello_point_cut'),
           path.join(__dirname, 'fixtures/modules/state_point_cut'),
@@ -166,8 +174,9 @@ describe('test/aop-runtime.test.ts', () => {
     beforeEach(async () => {
       crosscutAdviceFactory = new CrosscutAdviceFactory();
       eggObjectAopHook = new EggObjectAopHook();
-      loadUnitAopHook = new LoadUnitAopHook(crosscutAdviceFactory);
-      eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook(crosscutAdviceFactory);
+      loadUnitAopHook = createLoadUnitAopHook(crosscutAdviceFactory);
+      eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook();
+      Reflect.set(eggPrototypeCrossCutHook, 'crosscutAdviceFactory', crosscutAdviceFactory);
       EggPrototypeLifecycleUtil.registerLifecycle(eggPrototypeCrossCutHook);
       LoadUnitLifecycleUtil.registerLifecycle(loadUnitAopHook);
       EggObjectLifecycleUtil.registerLifecycle(eggObjectAopHook);
@@ -176,7 +185,6 @@ describe('test/aop-runtime.test.ts', () => {
     it('should throw', async () => {
       await assert.rejects(async () => {
         await CoreTestHelper.prepareModules([
-          path.join(__dirname, '..'),
           path.join(__dirname, 'fixtures/modules/should_throw'),
         ]);
       }, /Aop Advice\(PointcutAdvice\) not found in loadUnits/);
@@ -193,15 +201,15 @@ describe('test/aop-runtime.test.ts', () => {
     beforeEach(async () => {
       crosscutAdviceFactory = new CrosscutAdviceFactory();
       eggObjectAopHook = new EggObjectAopHook();
-      loadUnitAopHook = new LoadUnitAopHook(crosscutAdviceFactory);
-      eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook(crosscutAdviceFactory);
+      loadUnitAopHook = createLoadUnitAopHook(crosscutAdviceFactory);
+      eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook();
+      Reflect.set(eggPrototypeCrossCutHook, 'crosscutAdviceFactory', crosscutAdviceFactory);
       EggPrototypeLifecycleUtil.registerLifecycle(eggPrototypeCrossCutHook);
       LoadUnitLifecycleUtil.registerLifecycle(loadUnitAopHook);
       EggObjectLifecycleUtil.registerLifecycle(eggObjectAopHook);
 
       modules = await CoreTestHelper.prepareModules(
         [
-          path.join(__dirname, '..'),
           path.join(__dirname, 'fixtures/modules/constructor_inject_aop'),
           path.join(__dirname, 'fixtures/modules/hello_point_cut'),
           path.join(__dirname, 'fixtures/modules/hello_cross_cut'),

tegg/core/common-util/src/ModuleConfig.ts

@@ -36,6 +36,12 @@ const DEFAULT_READ_MODULE_REF_OPTS = {
 
 const CONFIG_NAMES_SLOT = Symbol('tegg:common-util:moduleConfigNames');
 
+export interface ResolvedModuleConfig {
+  name: string;
+  path: string;
+  config: ModuleConfig;
+}
+
 export class ModuleConfigUtil {
   // Per-app/per-Runner: each standalone Runner (and app) has distinct config
   // names (env-based); a process-global static races across them (the standalone
@@ -80,15 +86,21 @@ export class ModuleConfigUtil {
         const pkgJson = path.posix.join(moduleReferenceConfig.package, 'package.json');
         const file = importResolve(pkgJson, options);
         const modulePath = path.dirname(file);
+        const pkg = ModuleConfigUtil.readPackageJsonSync(modulePath);
         moduleReference = {
           path: modulePath,
-          name: ModuleConfigUtil.readModuleNameSync(modulePath),
+          name: ModuleConfigUtil.getModuleName(pkg),
+          package: ModuleConfigUtil.getPackageName(pkg),
+          ...(moduleReferenceConfig.optional === undefined ? {} : { optional: moduleReferenceConfig.optional }),
         };
       } else if (ModuleReferenceConfigHelp.isInlineModuleReference(moduleReferenceConfig)) {
         const modulePath = path.join(configDir, moduleReferenceConfig.path);
+        const pkg = ModuleConfigUtil.readPackageJsonSync(modulePath);
         moduleReference = {
           path: modulePath,
-          name: ModuleConfigUtil.readModuleNameSync(modulePath),
+          name: ModuleConfigUtil.getModuleName(pkg),
+          package: ModuleConfigUtil.getPackageName(pkg),
+          ...(moduleReferenceConfig.optional === undefined ? {} : { optional: moduleReferenceConfig.optional }),
         };
       } else {
         throw new Error('unknown type of module reference config: ' + JSON.stringify(moduleReferenceConfig));
@@ -138,15 +150,18 @@ export class ModuleConfigUtil {
       }
       moduleDirSet.add(moduleDir);
 
+      let pkg: any;
       let name: string;
       try {
-        name = this.readModuleNameSync(moduleDir);
+        pkg = this.readPackageJsonSync(moduleDir);
+        name = this.getModuleName(pkg);
       } catch {
         continue;
       }
       ref.push({
         path: moduleDir,
         name,
+        package: this.getPackageName(pkg),
       });
     }
     const moduleReferences = this.readModuleFromNodeModules(baseDir);
@@ -157,10 +172,7 @@ export class ModuleConfigUtil {
           throw new Error('duplicate import of module reference: ' + moduleBasePath);
         }
       });
-      ref.push({
-        path: moduleReference.path,
-        name: moduleReference.name,
-      });
+      ref.push(moduleReference);
     }
     return ref;
   }
@@ -188,10 +200,11 @@ export class ModuleConfigUtil {
       const absolutePkgPath = path.dirname(packageJsonPath);
       const realPkgPath = fs.realpathSync(absolutePkgPath);
       try {
-        const name = this.readModuleNameSync(realPkgPath);
+        const pkg = this.readPackageJsonSync(realPkgPath);
         ref.push({
           path: realPkgPath,
-          name,
+          name: this.getModuleName(pkg),
+          package: this.getPackageName(pkg),
         });
       } catch {
         continue;
@@ -213,6 +226,15 @@ export class ModuleConfigUtil {
     return pkg.eggModule.name;
   }
 
+  private static getPackageName(pkg: any): string | undefined {
+    return pkg.name;
+  }
+
+  private static readPackageJsonSync(moduleDir: string): any {
+    const pkgContent = fs.readFileSync(path.join(moduleDir, 'package.json'), 'utf8');
+    return JSON.parse(pkgContent);
+  }
+
   public static async readModuleName(baseDir: string, moduleDir: string): Promise<string> {
     moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
     const pkgContent = await fsPromise.readFile(path.join(moduleDir, 'package.json'), 'utf8');
@@ -222,8 +244,7 @@ export class ModuleConfigUtil {
 
   public static readModuleNameSync(moduleDir: string, baseDir?: string): string {
     moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
-    const pkgContent = fs.readFileSync(path.join(moduleDir, 'package.json'), 'utf8');
-    const pkg = JSON.parse(pkgContent);
+    const pkg = ModuleConfigUtil.readPackageJsonSync(moduleDir);
     return ModuleConfigUtil.getModuleName(pkg);
   }
 
@@ -306,6 +327,32 @@ export class ModuleConfigUtil {
     return target;
   }
 
+  public static resolveModuleConfigTolerant(
+    reference: ModuleReference,
+    baseDir?: string,
+    env?: string,
+  ): ResolvedModuleConfig {
+    if (!path.isAbsolute(reference.path)) {
+      assert(baseDir, 'baseDir is required for relative module reference path');
+    }
+    const modulePath = path.isAbsolute(reference.path) ? reference.path : path.resolve(baseDir!, reference.path);
+
+    if (!fs.existsSync(modulePath) && reference.name) {
+      return {
+        name: reference.name,
+        path: modulePath,
+        config: {},
+      };
+    }
+
+    const name = ModuleConfigUtil.readModuleNameSync(modulePath);
+    return {
+      name,
+      path: modulePath,
+      config: ModuleConfigUtil.loadModuleConfigSync(modulePath, undefined, env),
+    };
+  }
+
   static #loadOneSync(moduleDir: string, configName: string): ModuleConfig | undefined {
     const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
     let config = ModuleConfigUtil.#loadYamlSync(yamlConfigPath);