feat: impl GlobalGraph build hook

core/aop-decorator/src/AspectMetaBuilder.ts

@@ -26,7 +26,7 @@ export class AspectMetaBuilder {
     return aspectList;
   }
 
-  private static getAllMethods(clazz): PropertyKey[] {
+  static getAllMethods(clazz): PropertyKey[] {
     const methodSet = new Set<string>();
     function getMethods(obj) {
       if (obj) {

core/aop-runtime/index.ts

@@ -1,3 +1,6 @@
 export * from './src/EggPrototypeCrossCutHook';
 export * from './src/EggObjectAopHook';
 export * from './src/LoadUnitAopHook';
+
+export * from './src/CrossCutGraphHook';
+export * from './src/PointCutGraphHook';

core/aop-runtime/src/CrossCutGraphHook.ts

@@ -0,0 +1,63 @@
+import { AspectMetaBuilder, CrosscutInfo, CrosscutInfoUtil } from '@eggjs/aop-decorator';
+import { GraphNode } from '@eggjs/tegg-common-util';
+import {
+  ClassProtoDescriptor,
+  GlobalGraph,
+  ProtoDependencyMeta,
+  ProtoNode,
+} from '@eggjs/tegg-metadata';
+
+export function crossCutGraphHook(globalGraph: GlobalGraph) {
+  for (const moduleNode of globalGraph.moduleGraph.nodes.values()) {
+    for (const crossCutProtoNode of moduleNode.val.protos) {
+      const protoNodes = findCrossCuttedClazz(globalGraph, crossCutProtoNode);
+      if (!protoNodes) continue;
+      for (const crossCuttedProtoNode of protoNodes) {
+        const crossCuttedModuleNode = globalGraph.findModuleNode(crossCuttedProtoNode.val.proto.instanceModuleName);
+        if (!crossCuttedModuleNode) continue;
+        globalGraph.addInject(
+          crossCuttedModuleNode,
+          crossCuttedProtoNode,
+          crossCutProtoNode,
+          crossCutProtoNode.val.proto.name);
+      }
+    }
+  }
+}
+
+function findCrossCuttedClazz(globalGraph: GlobalGraph, protoNode: GraphNode<ProtoNode, ProtoDependencyMeta>) {
+  const proto = protoNode.val.proto;
+  if (!ClassProtoDescriptor.isClassProtoDescriptor(proto)) {
+    return;
+  }
+  if (!CrosscutInfoUtil.isCrosscutAdvice(proto.clazz)) {
+    return;
+  }
+  const crosscutInfoList = CrosscutInfoUtil.getCrosscutInfoList(proto.clazz);
+  const result: GraphNode<ProtoNode, ProtoDependencyMeta>[] = [];
+  // eslint-disable-next-line no-labels
+  crosscut: for (const crosscutInfo of crosscutInfoList) {
+    for (const protoNode of globalGraph.protoGraph.nodes.values()) {
+      if (checkClazzMatchCrossCut(protoNode, crosscutInfo)) {
+        result.push(protoNode);
+        // eslint-disable-next-line no-labels
+        break crosscut;
+      }
+    }
+  }
+  return result;
+}
+
+function checkClazzMatchCrossCut(protoNode: GraphNode<ProtoNode>, crosscutInfo: CrosscutInfo) {
+  const proto = protoNode.val.proto;
+  if (!ClassProtoDescriptor.isClassProtoDescriptor(proto)) {
+    return;
+  }
+  const allMethods = AspectMetaBuilder.getAllMethods(proto.clazz);
+  for (const method of allMethods) {
+    if (crosscutInfo.pointcutInfo.match(proto.clazz, method)) {
+      return true;
+    }
+  }
+  return false;
+}

core/aop-runtime/src/PointCutGraphHook.ts

@@ -0,0 +1,54 @@
+import { AspectMetaBuilder, PointcutAdviceInfoUtil } from '@eggjs/aop-decorator';
+import { PrototypeUtil, QualifierUtil } from '@eggjs/core-decorator';
+import { GraphNode } from '@eggjs/tegg-common-util';
+import {
+  ClassProtoDescriptor,
+  GlobalGraph,
+  ProtoDependencyMeta,
+  ProtoNode,
+} from '@eggjs/tegg-metadata';
+import assert from 'node:assert';
+
+export function pointCutGraphHook(globalGraph: GlobalGraph) {
+  for (const moduleNode of globalGraph.moduleGraph.nodes.values()) {
+    for (const pointCuttedProtoNode of moduleNode.val.protos) {
+      const pointCutAdviceProtoList = findPointCutAdvice(globalGraph, pointCuttedProtoNode);
+      if (!pointCutAdviceProtoList) continue;
+      for (const pointCutAdviceProto of pointCutAdviceProtoList) {
+        globalGraph.addInject(
+          moduleNode,
+          pointCuttedProtoNode,
+          pointCutAdviceProto,
+          pointCutAdviceProto.val.proto.name);
+      }
+    }
+  }
+}
+
+function findPointCutAdvice(globalGraph: GlobalGraph, protoNode: GraphNode<ProtoNode, ProtoDependencyMeta>) {
+  const proto = protoNode.val.proto;
+  if (!ClassProtoDescriptor.isClassProtoDescriptor(proto)) {
+    return;
+  }
+  const result: Set<GraphNode<ProtoNode, ProtoDependencyMeta>> = new Set();
+  const allMethods = AspectMetaBuilder.getAllMethods(proto.clazz);
+  for (const method of allMethods) {
+    const adviceInfoList = PointcutAdviceInfoUtil.getPointcutAdviceInfoList(proto.clazz, method);
+    for (const { clazz } of adviceInfoList) {
+      const property = PrototypeUtil.getProperty(clazz);
+      assert(property, 'not found property');
+      const injectProto = globalGraph.findDependencyProtoNode(protoNode.val.proto, {
+        objName: property.name,
+        refName: property.name,
+        qualifiers: [
+          ...property?.qualifiers ?? [],
+          ...QualifierUtil.getProtoQualifiers(clazz),
+        ],
+      });
+      if (injectProto) {
+        result.add(injectProto);
+      }
+    }
+  }
+  return Array.from(result);
+}

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

@@ -6,10 +6,15 @@ import { EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } fro
 import type { LoadUnitInstance } from '@eggjs/tegg-types';
 import { CrosscutAdviceFactory } from '@eggjs/aop-decorator';
 import { CoreTestHelper, EggTestContext } from '../../test-util';
-import { CallTrace, Hello, crosscutAdviceParams, pointcutAdviceParams } from './fixtures/modules/hello_succeed/Hello';
+import { Hello } from './fixtures/modules/hello_succeed/Hello';
+import { crosscutAdviceParams } from './fixtures/modules/hello_cross_cut/HelloCrossCut';
+import { pointcutAdviceParams } from './fixtures/modules/hello_point_cut/HelloPointCut';
 import { EggObjectAopHook } from '../src/EggObjectAopHook';
 import { LoadUnitAopHook } from '../src/LoadUnitAopHook';
 import { EggPrototypeCrossCutHook } from '../src/EggPrototypeCrossCutHook';
+import { crossCutGraphHook } from '../src/CrossCutGraphHook';
+import { pointCutGraphHook } from '../src/PointCutGraphHook';
+import { CallTrace } from './fixtures/modules/hello_cross_cut/CallTrace';
 
 describe('test/aop-runtime.test.ts', () => {
   describe('succeed call', () => {
@@ -31,6 +36,11 @@ describe('test/aop-runtime.test.ts', () => {
       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/hello_cross_cut'),
+      ], [
+        crossCutGraphHook,
+        pointCutGraphHook,
       ]);
     });
 

core/aop-runtime/test/fixtures/modules/hello_cross_cut/CallTrace.ts

@@ -0,0 +1,21 @@
+import { AccessLevel, SingletonProto } from "@eggjs/core-decorator";
+
+export interface CallTraceMsg {
+  className: string;
+  methodName: string;
+  id: number;
+  name: string;
+  result?: string;
+  adviceParams?: any;
+}
+
+@SingletonProto({
+  accessLevel: AccessLevel.PUBLIC,
+})
+export class CallTrace {
+  msgs: Array<CallTraceMsg> = [];
+
+  addMsg(msg: CallTraceMsg) {
+    this.msgs.push(msg);
+  }
+}

core/aop-runtime/test/fixtures/modules/hello_cross_cut/HelloCrossCut.ts

@@ -0,0 +1,69 @@
+import assert from 'node:assert';
+import { AccessLevel, Inject } from '@eggjs/core-decorator';
+import { Advice, Crosscut } from '@eggjs/aop-decorator';
+import { AdviceContext, IAdvice, PointcutType } from '@eggjs/tegg-types';
+import { Hello } from '../hello_succeed/Hello';
+import { CallTrace } from './CallTrace';
+
+export const crosscutAdviceParams = {
+  cross: Math.random().toString(),
+  cut: Math.random().toString(),
+};
+
+@Crosscut({
+  type: PointcutType.CLASS,
+  clazz: Hello,
+  methodName: 'hello',
+}, { adviceParams: crosscutAdviceParams })
+@Advice({
+  accessLevel: AccessLevel.PUBLIC,
+})
+export class CrosscutAdvice implements IAdvice<Hello, string> {
+  @Inject()
+  callTrace: CallTrace;
+
+  async beforeCall(ctx: AdviceContext<Hello, {}>): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, crosscutAdviceParams);
+    this.callTrace.addMsg({
+      className: CrosscutAdvice.name,
+      methodName: 'beforeCall',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      adviceParams: ctx.adviceParams,
+    });
+  }
+
+  async afterReturn(ctx: AdviceContext<Hello>, result: any): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, crosscutAdviceParams);
+    this.callTrace.addMsg({
+      className: CrosscutAdvice.name,
+      methodName: 'afterReturn',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      result,
+      adviceParams: ctx.adviceParams,
+    });
+  }
+
+  async afterFinally(ctx: AdviceContext<Hello>): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, crosscutAdviceParams);
+    this.callTrace.addMsg({
+      className: CrosscutAdvice.name,
+      methodName: 'afterFinally',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      adviceParams: ctx.adviceParams,
+    });
+  }
+
+  async around(ctx: AdviceContext<Hello>, next: () => Promise<any>): Promise<any> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, crosscutAdviceParams);
+    ctx.args[0] = `withCrosscutAroundParam(${ctx.args[0]})`;
+    const result = await next();
+    return `withCrossAroundResult(${result}${JSON.stringify(ctx.adviceParams)})`;
+  }
+}

core/aop-runtime/test/fixtures/modules/hello_cross_cut/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "hello-cross-cut",
+  "eggModule": {
+    "name": "helloCrossCut"
+  }
+}

core/aop-runtime/test/fixtures/modules/hello_point_cut/HelloPointCut.ts

@@ -0,0 +1,82 @@
+import assert from 'node:assert';
+import { AccessLevel, Inject } from '@eggjs/core-decorator';
+import { Advice } from '@eggjs/aop-decorator';
+import { AdviceContext, IAdvice } from '@eggjs/tegg-types';
+import { Hello } from '../hello_succeed/Hello';
+import { CallTrace } from '../hello_cross_cut/CallTrace';
+
+export const pointcutAdviceParams = {
+  point: Math.random().toString(),
+  cut: Math.random().toString(),
+};
+
+// 测试aop修改ctx的args的值
+const TEST_CTX_ARGS_VALUE = 123;
+
+@Advice({
+  accessLevel: AccessLevel.PUBLIC,
+})
+export class PointcutAdvice implements IAdvice<Hello> {
+  @Inject()
+  callTrace: CallTrace;
+
+  async beforeCall(ctx: AdviceContext<Hello>): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, pointcutAdviceParams);
+    this.callTrace.addMsg({
+      className: PointcutAdvice.name,
+      methodName: 'beforeCall',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      adviceParams: ctx.adviceParams,
+    });
+    ctx.args = [...ctx.args, TEST_CTX_ARGS_VALUE];
+  }
+
+  async afterReturn(ctx: AdviceContext<Hello>, result: any): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, pointcutAdviceParams);
+    assert.deepStrictEqual(ctx.args[ctx.args.length - 1], TEST_CTX_ARGS_VALUE);
+    this.callTrace.addMsg({
+      className: PointcutAdvice.name,
+      methodName: 'afterReturn',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      result,
+      adviceParams: ctx.adviceParams,
+    });
+  }
+
+  async afterThrow(ctx: AdviceContext<Hello, any>, error: Error): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, pointcutAdviceParams);
+    this.callTrace.addMsg({
+      className: PointcutAdvice.name,
+      methodName: 'afterThrow',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      result: error.message,
+      adviceParams: ctx.adviceParams,
+    });
+  }
+
+  async afterFinally(ctx: AdviceContext<Hello>): Promise<void> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, pointcutAdviceParams);
+    this.callTrace.addMsg({
+      className: PointcutAdvice.name,
+      methodName: 'afterFinally',
+      id: ctx.that.id,
+      name: ctx.args[0],
+      adviceParams: ctx.adviceParams,
+    });
+  }
+
+  async around(ctx: AdviceContext<Hello>, next: () => Promise<any>): Promise<any> {
+    assert.ok(ctx.adviceParams);
+    assert.deepStrictEqual(ctx.adviceParams, pointcutAdviceParams);
+    ctx.args[0] = `withPointAroundParam(${ctx.args[0]})`;
+    const result = await next();
+    return `withPointAroundResult(${result}${JSON.stringify(pointcutAdviceParams)})`;
+  }
+}

core/aop-runtime/test/fixtures/modules/hello_point_cut/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "hello-point-cut",
+  "eggModule": {
+    "name": "helloPointCut"
+  }
+}