Add DI, AOP support for eggjs.

import { Service, Context } from 'egg';
import { context, lazyInject } from 'egg-aop';

@context() // or @application()
export class TestService extends Service {
  get() {
    /* code */
  }
}

export class Controller {
  @lazyInject()
  private testService: TestService;
  
  demo() {
    this.testService.get();
  }
}

• @context(keyType?: any)

  Declaration of life cycle of an instance, is context level. You can provide a class type or from metadata by TypeScript emit.

• @application(keyType?: any)

  Declaration of life cycle of an instance, is context level. You can provide a class type or from metadata by TypeScript emit.

• @inject(keyType?: any)

  Inject component when the class is instantiated.

• @lazyInject(keyType?: any)

  Inject component when accessing the property.

• getInstance<T = any>(clsType: any, app: any, ctx: any): T

  You can use this function to manually get the component instance.

• setCreateInstanceHook(func: CreateInstanceHookFunction)

  You can use this function to interception every new component instance.

  type CreateInstanceHookFunction = (instance: any, app: any, ctx?: any) => any;

typeLoader is an instance of IocContext, it stores all type's classes. You can use this to affect DI behavior.

function logging(type: string) {
  return aspect({
    // before method running
    before: (context) => { /* log code */ },
    // after method running
    after: (context) => { /* log code */ },
    // when method throw error
    onError: (context) => { /* log code */ },
  })
}

class DemoService {
  @logging('create')
  createData() {
    /* code */
  }
}

/* FunctionContext type define */
export interface FunctionContext<T = any> {
  readonly inst: T;
  readonly functionName: string;
  args: any[];
  ret: any;
  err: Error;
}

• aspect<T = any>(point: AspectPoint<T> = {})

  You can use this to intercept method, this function provides before / after / error cross-sections.

  interface AspectPoint<T = any> {
    before?: (context: FunctionContext<T>) => void;
    after?: (context: FunctionContext<T>) => void;
    error?: (context: FunctionContext<T>) => void;
  }

  The param context is the function's execution context. It includes inst / args / ret. You can replace them to affect the function execution.