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

@@ -3,16 +3,17 @@ import path from 'node:path';
 import { mock } from 'node:test';
 
 import { CrosscutAdviceFactory } from '@eggjs/aop-decorator';
-import { EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from '@eggjs/metadata';
-import { CoreTestHelper, EggTestContext } from '@eggjs/module-test-util';
-import { EggObjectLifecycleUtil, LoadUnitInstanceFactory } from '@eggjs/tegg-runtime';
+import { EggPrototypeLifecycleUtil, LoadUnitLifecycleUtil } from '@eggjs/metadata';
+import { CoreTestHelper, EggTestContext, LoaderUtil } from '@eggjs/module-test-util';
+import { EggObjectLifecycleUtil } from '@eggjs/tegg-runtime';
 import type { LoadUnitInstance } from '@eggjs/tegg-types';
 import { describe, beforeEach, afterEach, it } from 'vitest';
 
 // must import before other imports
 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'),
@@ -56,10 +64,7 @@ describe('test/aop-runtime.test.ts', () => {
     });
 
     afterEach(async () => {
-      for (const module of modules) {
-        await LoadUnitFactory.destroyLoadUnit(module.loadUnit);
-        await LoadUnitInstanceFactory.destroyLoadUnitInstance(module);
-      }
+      await CoreTestHelper.destroyModules(modules);
       EggPrototypeLifecycleUtil.deleteLifecycle(eggPrototypeCrossCutHook);
       LoadUnitLifecycleUtil.deleteLifecycle(loadUnitAopHook);
       EggObjectLifecycleUtil.deleteLifecycle(eggObjectAopHook);
@@ -166,20 +171,31 @@ 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);
     });
 
+    afterEach(() => {
+      EggPrototypeLifecycleUtil.deleteLifecycle(eggPrototypeCrossCutHook);
+      LoadUnitLifecycleUtil.deleteLifecycle(loadUnitAopHook);
+      EggObjectLifecycleUtil.deleteLifecycle(eggObjectAopHook);
+    });
+
     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/);
+      const modulePath = path.join(__dirname, 'fixtures/modules/should_throw');
+      const { innerObjectLoadUnitInstance } = await LoaderUtil.buildGlobalGraph([modulePath]);
+      try {
+        await assert.rejects(
+          () => CoreTestHelper.getLoadUnitInstance(modulePath),
+          /Aop Advice\(PointcutAdvice\) not found in loadUnits/,
+        );
+      } finally {
+        await CoreTestHelper.destroyModules([innerObjectLoadUnitInstance]);
+      }
     });
   });
 
@@ -193,15 +209,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'),
@@ -211,10 +227,7 @@ describe('test/aop-runtime.test.ts', () => {
     });
 
     afterEach(async () => {
-      for (const module of modules) {
-        await LoadUnitFactory.destroyLoadUnit(module.loadUnit);
-        await LoadUnitInstanceFactory.destroyLoadUnitInstance(module);
-      }
+      await CoreTestHelper.destroyModules(modules);
       EggPrototypeLifecycleUtil.deleteLifecycle(eggPrototypeCrossCutHook);
       LoadUnitLifecycleUtil.deleteLifecycle(loadUnitAopHook);
       EggObjectLifecycleUtil.deleteLifecycle(eggObjectAopHook);