feat: impl aop

Author: killagu

core/aop-decorator/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

core/aop-decorator/README.md

@@ -0,0 +1,5 @@
+# `@eggjs/aop-decorator`
+
+# Usage
+
+Please read [@eggjs/tegg-aop-plugin](../../plugin/aop/README.md)

core/aop-decorator/index.ts

@@ -0,0 +1,11 @@
+export * from './src/decorator/Advice';
+export * from './src/decorator/Pointcut';
+export * from './src/decorator/Cosscut';
+export * from './src/model/Aspect';
+export * from './src/model/PointcutInfo';
+export * from './src/util/AdviceInfoUtil';
+export * from './src/util/CrosscutInfoUtil';
+export * from './src/util/PointcutAdviceInfoUtil';
+export * from './src/util/AspectInfoUtil';
+export * from './src/AspectMetaBuilder';
+export * from './src/CrosscutAdviceFactory';

core/aop-decorator/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@eggjs/aop-decorator",
+  "version": "0.1.19",
+  "description": "tegg aop decorator",
+  "keywords": [
+    "tegg",
+    "aop",
+    "typescript",
+    "egg"
+  ],
+  "author": "killagu <[email protected]>",
+  "homepage": "https://github.com/eggjs/tegg",
+  "repository": {
+    "type": "git",
+    "url": "[email protected]:eggjs/tegg.git",
+    "directory": "core/aop-decorator"
+  },
+  "dependencies": {
+    "@eggjs/core-decorator": "^0.1.19",
+    "@eggjs/tegg-common-util": "^0.1.19",
+    "@eggjs/tegg-metadata": "^0.1.19"
+  },
+  "scripts": {
+    "clean": "tsc -b --clean",
+    "tsc": "npm run clean && tsc -p ./tsconfig.json",
+    "tsc:pub": "npm run clean && tsc -p ./tsconfig.pub.json",
+    "prepublishOnly": "npm run tsc:pub",
+    "autod": "autod"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "bugs": {
+    "url": "https://github.com/eggjs/tegg/issues"
+  }
+}

core/aop-decorator/src/AspectMetaBuilder.ts

@@ -0,0 +1,62 @@
+import { CrosscutAdviceFactory } from './CrosscutAdviceFactory';
+import { EggProtoImplClass } from '@eggjs/core-decorator';
+import { Aspect, AspectBuilder } from './model/Aspect';
+import { PointcutAdviceInfoUtil } from './util/PointcutAdviceInfoUtil';
+
+export class AspectMetaBuilder {
+  private readonly clazz: EggProtoImplClass;
+  private readonly crosscutAdviceFactory: CrosscutAdviceFactory;
+
+  constructor(clazz: EggProtoImplClass, options: {
+    crosscutAdviceFactory: CrosscutAdviceFactory;
+  }) {
+    this.clazz = clazz;
+    this.crosscutAdviceFactory = options.crosscutAdviceFactory;
+  }
+
+  build(): Array<Aspect> {
+    const aspectList: Array<Aspect> = [];
+    const methods = AspectMetaBuilder.getAllMethods(this.clazz);
+    for (const method of methods) {
+      const aspect = this.doBuildMethodAspect(method);
+      if (aspect) {
+        aspectList.push(aspect);
+      }
+    }
+    return aspectList;
+  }
+
+  private static getAllMethods(clazz): PropertyKey[] {
+    const methodSet = new Set<string>();
+    function getMethods(obj) {
+      if (obj) {
+        const names = Object.getOwnPropertyNames(obj);
+        for (const name of names) {
+          if (obj[name] instanceof Function) {
+            methodSet.add(name);
+          }
+        }
+        getMethods(Object.getPrototypeOf(obj));
+      }
+    }
+
+    getMethods(clazz.prototype);
+
+    return Array.from(methodSet);
+  }
+
+  private doBuildMethodAspect(method: PropertyKey): Aspect | undefined {
+    const crosscutAdviceList = this.crosscutAdviceFactory.getAdvice(this.clazz, method);
+    // decorator execute in reverse order
+    const pointcutAdviceList = PointcutAdviceInfoUtil.getPointcutAdviceInfoList(this.clazz, method);
+    if (!crosscutAdviceList.length && !pointcutAdviceList.length) return;
+    const aspectBuilder = new AspectBuilder(this.clazz, method);
+    for (const advice of crosscutAdviceList) {
+      aspectBuilder.addAdvice(advice);
+    }
+    for (const advice of pointcutAdviceList) {
+      aspectBuilder.addAdvice(advice);
+    }
+    return aspectBuilder.build();
+  }
+}

core/aop-decorator/src/CrosscutAdviceFactory.ts

@@ -0,0 +1,27 @@
+import assert from 'assert';
+import { EggProtoImplClass } from '@eggjs/core-decorator';
+import { IAdvice } from './decorator/Advice';
+import { CrosscutInfoUtil } from './util/CrosscutInfoUtil';
+import { AdviceInfo } from './model/Aspect';
+
+export class CrosscutAdviceFactory {
+  private readonly crosscutAdviceClazzList: Array<EggProtoImplClass<IAdvice>> = [];
+
+  registerCrossAdviceClazz(clazz: EggProtoImplClass<IAdvice>) {
+    assert(CrosscutInfoUtil.isCrosscutAdvice(clazz), `clazz ${clazz.name} is not crosscut advice`);
+    this.crosscutAdviceClazzList.push(clazz);
+  }
+
+  getAdvice(clazz: EggProtoImplClass, method: PropertyKey): Array<AdviceInfo> {
+    const result: Array<AdviceInfo> = [];
+    for (const crosscutAdviceClazz of this.crosscutAdviceClazzList) {
+      const crosscutInfoList = CrosscutInfoUtil.getCrosscutInfoList(crosscutAdviceClazz);
+      for (const crosscutInfo of crosscutInfoList) {
+        if (crosscutInfo.pointcutInfo.match(clazz, method)) {
+          result.push(crosscutInfo.adviceInfo);
+        }
+      }
+    }
+    return result;
+  }
+}

core/aop-decorator/src/decorator/Advice.ts

@@ -0,0 +1,66 @@
+import {
+  AccessLevel,
+  EggProtoImplClass,
+  ObjectInitType,
+  Prototype,
+  PrototypeParams,
+} from '@eggjs/core-decorator';
+import { AdviceInfoUtil } from '../util/AdviceInfoUtil';
+
+export interface AdviceContext<T = object> {
+  that: T;
+  method: PropertyKey;
+  args: any[];
+}
+
+/**
+ * execute order:
+ * 1. beforeCall
+ * 1. around
+ * 1. afterReturn/afterThrow
+ * 1. afterFinally
+ */
+export interface IAdvice<T = object> {
+  /**
+   * call before function
+   * @param ctx
+   */
+  beforeCall?(ctx: AdviceContext<T>): Promise<void>;
+
+  /**
+   * call after function succeed
+   */
+  afterReturn?(ctx: AdviceContext<T>, result: any): Promise<void>;
+
+  /**
+   * call after function throw error
+   */
+  afterThrow?(ctx: AdviceContext<T>, error: Error): Promise<void>;
+
+  /**
+   * always call after function done
+   */
+  afterFinally?(ctx: AdviceContext<T>): Promise<void>;
+
+  /**
+   * execute the function
+   * the only one can modify the function return value
+   */
+  around?(ctx: AdviceContext<T>, next: () => Promise<any>): Promise<any>;
+}
+
+const defaultAdviceParam = {
+  accessLevel: AccessLevel.PUBLIC,
+  initType: ObjectInitType.CONTEXT,
+};
+
+export function Advice(param?: PrototypeParams) {
+  return function(constructor: EggProtoImplClass<IAdvice>) {
+    AdviceInfoUtil.setIsAdvice(true, constructor);
+    const func = Prototype({
+      ...defaultAdviceParam,
+      ...param,
+    });
+    func(constructor);
+  };
+}

core/aop-decorator/src/decorator/Cosscut.ts

@@ -0,0 +1,73 @@
+import { EggProtoImplClass } from '@eggjs/core-decorator';
+import { IAdvice } from './Advice';
+import { CrosscutInfo, CrosscutInfoUtil } from '../util/CrosscutInfoUtil';
+import {
+  ClassPointInfo,
+  CustomPointcutCallback,
+  CustomPointInfo,
+  NamePointInfo,
+  PointcutType,
+} from '../model/PointcutInfo';
+
+export interface CrosscutOptions {
+  // 默认值 100
+  order?: number;
+}
+
+const defaultCrossOptions = {
+  order: 100,
+};
+
+// TODO type check for methodName
+export interface ClassCrosscutParam {
+  type: PointcutType.CLASS;
+  clazz: EggProtoImplClass;
+  methodName: PropertyKey;
+}
+
+export interface NameCrosscutParam {
+  type: PointcutType.NAME;
+  className: RegExp;
+  methodName: RegExp;
+}
+
+
+export interface CustomCrosscutParam {
+  type: PointcutType.CUSTOM;
+  callback: CustomPointcutCallback;
+}
+
+export type CrosscutParam = ClassCrosscutParam | NameCrosscutParam | CustomCrosscutParam;
+
+export function Crosscut(param: CrosscutParam, options?: CrosscutOptions) {
+  return function(constructor: EggProtoImplClass<IAdvice>) {
+    let crosscutInfo: CrosscutInfo;
+    if (param.type === PointcutType.CLASS) {
+      crosscutInfo = {
+        pointcutInfo: new ClassPointInfo(param.clazz, param.methodName),
+        adviceInfo: {
+          clazz: constructor,
+          order: options?.order ?? defaultCrossOptions.order,
+        },
+      };
+    } else if (param.type === PointcutType.NAME) {
+      crosscutInfo = {
+        pointcutInfo: new NamePointInfo(param.className, param.methodName),
+        adviceInfo: {
+          clazz: constructor,
+          order: options?.order ?? defaultCrossOptions.order,
+        },
+      };
+    } else {
+      crosscutInfo = {
+        pointcutInfo: new CustomPointInfo(param.callback),
+        adviceInfo: {
+          clazz: constructor,
+          order: options?.order ?? defaultCrossOptions.order,
+        },
+      };
+    }
+    CrosscutInfoUtil.setIsCrosscutAdvice(true, constructor);
+    CrosscutInfoUtil.addCrosscutInfo(crosscutInfo, constructor);
+  };
+}

core/aop-decorator/src/decorator/Pointcut.ts

@@ -0,0 +1,26 @@
+import { IAdvice } from './Advice';
+import { EggProtoImplClass } from '@eggjs/core-decorator';
+import { PointcutAdviceInfoUtil } from '../util/PointcutAdviceInfoUtil';
+import assert from 'assert';
+import { AdviceInfoUtil } from '../util/AdviceInfoUtil';
+
+export interface PointcutOptions {
+  // default is 1000
+  order?: number;
+}
+
+const defaultPointcutOptions = {
+  order: 1000,
+};
+
+export function Pointcut(adviceClazz: EggProtoImplClass<IAdvice>, options?: PointcutOptions) {
+  return function(target: any, propertyKey: PropertyKey) {
+    assert(AdviceInfoUtil.isAdvice(adviceClazz), `class ${adviceClazz} has no @Advice decorator`);
+    const targetClazz = target.constructor as EggProtoImplClass;
+    const methodName = propertyKey as string;
+    PointcutAdviceInfoUtil.addPointcutAdviceInfo({
+      clazz: adviceClazz,
+      order: options?.order ?? defaultPointcutOptions.order,
+    }, targetClazz, methodName);
+  };
+}

core/aop-decorator/src/model/Aspect.ts

@@ -0,0 +1,55 @@
+import { EggProtoImplClass } from '@eggjs/core-decorator';
+import { IAdvice } from '../decorator/Advice';
+
+export interface AdviceInfo {
+  clazz: EggProtoImplClass<IAdvice>;
+  order: number;
+}
+
+export interface AspectAdvice {
+  name: string;
+  clazz: EggProtoImplClass<IAdvice>;
+}
+
+export class Aspect {
+  readonly clazz: EggProtoImplClass;
+  readonly method: PropertyKey;
+  readonly adviceList: readonly AspectAdvice[];
+
+  constructor(clazz: EggProtoImplClass, method: PropertyKey, adviceList: readonly AspectAdvice[]) {
+    this.clazz = clazz;
+    this.method = method;
+    this.adviceList = adviceList;
+  }
+}
+
+export class AspectBuilder {
+  readonly clazz: EggProtoImplClass;
+  readonly method: PropertyKey;
+  private readonly adviceList: Array<AdviceInfo>;
+
+  constructor(clazz: EggProtoImplClass, method: PropertyKey) {
+    this.clazz = clazz;
+    this.method = method;
+    this.adviceList = [];
+  }
+
+  addAdvice(adviceInfo: AdviceInfo) {
+    this.adviceList.push(adviceInfo);
+  }
+
+  build(): Aspect {
+    this.adviceList.sort((a, b) => a.order - b.order);
+    const aspectAdviceList = this.adviceList.map((t, i) => {
+      return {
+        clazz: t.clazz,
+        name: this.adviceName(t.clazz, i),
+      };
+    });
+    return new Aspect(this.clazz, this.method, aspectAdviceList);
+  }
+
+  private adviceName(advice: EggProtoImplClass<IAdvice>, index: number) {
+    return `${this.clazz.name}#${String(this.method)}#${advice.name}#${index}`;
+  }
+}