feat: impl MultiInstanceProto (#145)

<!--
Thank you for your pull request. Please review below requirements.
Bug fixes and new features should include tests and possibly benchmarks.
Contributors guide:
https://github.com/eggjs/egg/blob/master/CONTRIBUTING.md

感谢您贡献代码。请确认下列 checklist 的完成情况。
Bug 修复和新功能必须包含测试，必要时请附上性能测试。
Contributors guide:
https://github.com/eggjs/egg/blob/master/CONTRIBUTING.md
-->

##### Checklist
<!-- Remove items that do not apply. For completed items, change [ ] to
[x]. -->

- [x] `npm test` passes
- [x] tests and/or benchmarks are included
- [ ] documentation is changed or added
- [x] commit message follows commit guidelines

##### Affected core subsystem(s)
<!-- Provide affected core subsystem(s). -->


##### Description of change
<!-- Provide a description of the change below this comment. -->

<!--
- any feature?
- close https://github.com/eggjs/egg/ISSUE_URL
-->

Author: killagu

README.md

@@ -156,6 +156,172 @@ export class HelloService {
 }
 ```
 
+#### MultiInstanceProto
+
+支持一个类有多个实例。比如说 logger 可能会初始化多个，用来输出到不通文件，db 可能会初始化多个，用来连接不同的数据库。
+使用这个注解可以方便的对接外部资源。
+
+##### 定义
+```ts
+// 静态定义
+@MultiInstanceProto(params: {
+  // 对象的生命周期
+  // CONTEXT: 每个上下文都有一个实例
+  // SINGLETON: 整个应用生命周期只有一个实例
+  initType?: ObjectInitTypeLike;
+
+  // 对象是在 module 内可访问还是全局可访问
+  // PRIVATE: 仅 module 内可访问
+  // PUBLIC: 全局可访问
+  // 默认值为 PRIVATE
+  accessLevel?: AccessLevel;
+
+  // 高阶参数，指定类型的实现原型
+  protoImplType?: string;
+
+  // 对象元信息
+  objects: ObjectInfo[];
+})
+
+// 动态定义
+@MultiInstanceProto(params: {
+  // 对象的生命周期
+  // CONTEXT: 每个上下文都有一个实例
+  // SINGLETON: 整个应用生命周期只有一个实例
+  initType?: ObjectInitTypeLike;
+
+  // 对象是在 module 内可访问还是全局可访问
+  // PRIVATE: 仅 module 内可访问
+  // PUBLIC: 全局可访问
+  // 默认值为 PRIVATE
+  accessLevel?: AccessLevel;
+
+  // 高阶参数，指定类型的实现原型
+  protoImplType?: string;
+
+  // 动态调用，获取对象元信息
+  // 仅会调用一次，调用后结果会被缓存
+  getObjects(ctx: MultiInstancePrototypeGetObjectsContext): ObjectInfo[];
+})
+```
+
+##### 示例
+
+首先定义一个自定义 Qualifier 注解
+```ts
+import {
+  QualifierUtil,
+  EggProtoImplClass,
+} from '@eggjs/tegg';
+
+export const LOG_PATH_ATTRIBUTE = Symbol.for('LOG_PATH_ATTRIBUTE');
+
+export function LogPath(name: string) {
+  return function(target: any, propertyKey: PropertyKey) {
+    QualifierUtil.addProperQualifier(target.constructor as EggProtoImplClass, propertyKey, LOG_PATH_ATTRIBUTE, name);
+  };
+}
+
+```
+
+定一个具体实现
+
+```typescript
+import {
+  MultiInstanceProto,
+  MultiInstancePrototypeGetObjectsContext,
+  LifecycleInit,
+  LifecycleDestroy,
+  QualifierUtil,
+  EggProtoImplClass,
+} from '@eggjs/tegg';
+import { EggObject, ModuleConfigUtil, EggObjectLifeCycleContext } from '@eggjs/tegg/helper';
+import fs from 'node:fs';
+import { Writable } from 'node:stream';
+import path from 'node:path';
+import { EOL } from 'node:os';
+
+export const LOG_PATH_ATTRIBUTE = Symbol.for('LOG_PATH_ATTRIBUTE');
+
+@MultiInstanceProto({
+  // 从 module.yml 中动态获取配置来决定需要初始化几个对象
+  getObjects(ctx: MultiInstancePrototypeGetObjectsContext) {
+    const config = ModuleConfigUtil.loadModuleConfigSync(ctx.unitPath);
+    return (config as any).features.logger.map(name => {
+      return {
+        name: 'dynamicLogger',
+        qualifiers: [{
+          attribute: LOG_PATH_ATTRIBUTE,
+          value: name,
+        }],
+      }
+    });
+  },
+})
+export class DynamicLogger {
+  stream: Writable;
+  loggerName: string;
+
+  @LifecycleInit()
+  async init(ctx: EggObjectLifeCycleContext, obj: EggObject) {
+    // 获取需要实例化对象的 Qualifieri
+    const loggerName = obj.proto.getQualifier(LOG_PATH_ATTRIBUTE);
+    this.loggerName = loggerName as string;
+    this.stream = fs.createWriteStream(path.join(ctx.loadUnit.unitPath, `${loggerName}.log`));
+  }
+
+  @LifecycleDestroy()
+  async destroy() {
+    return new Promise<void>((resolve, reject) => {
+      this.stream.end(err => {
+        if (err)  {
+          return reject(err);
+        }
+        return resolve();
+      });
+    });
+  }
+
+  info(msg: string) {
+    return new Promise<void>((resolve, reject) => {
+      this.stream.write(msg + EOL,err => {
+        if (err)  {
+          return reject(err);
+        }
+        return resolve();
+      });
+    });
+  }
+
+}
+```
+
+使用 DynamicLogger.
+```ts
+@SingletonProto()
+export class Foo {
+  @Inject({
+    name: 'dynamicLogger',
+  })
+  // 通过自定义注解来指定 Qualifier
+  @LogPath('foo')
+  fooDynamicLogger: DynamicLogger;
+
+  @Inject({
+    name: 'dynamicLogger',
+  })
+  @LogPath('bar')
+  barDynamicLogger: DynamicLogger;
+
+  async hello(): Promise<void> {
+    await this.fooDynamicLogger.info('hello, foo');
+    await this.barDynamicLogger.info('hello, bar');
+  }
+}
+```
+
+
+
 #### 生命周期 hook
 
 由于对象的生命周期交给了容器来托管，代码中无法感知什么时候对象初始化，什么时候依赖被注入了。所以提供了生命周期 hook 来实现这些通知的功能。

core/core-decorator/README.md

@@ -1,5 +1,5 @@
-# `@eggjs/standalon-decorator`
+# `@eggjs/core-decorator`
 
 ## Usage
 
-Please read [@eggjs/tegg-standalone](../../standalone/standalone)
+Please read [@eggjs/tegg-plugin](../../plugin/tegg)

core/core-decorator/index.ts

@@ -5,6 +5,7 @@ export * from './src/decorator/ModuleQualifier';
 export * from './src/decorator/ContextProto';
 export * from './src/decorator/SingletonProto';
 export * from './src/decorator/EggQualifier';
+export * from './src/decorator/MultiInstanceProto';
 
 export * from './src/enum/AccessLevel';
 export * from './src/enum/ObjectInitType';
@@ -13,6 +14,7 @@ export * from './src/enum/EggType';
 export * from './src/model/EggPrototypeInfo';
 export * from './src/model/InjectObjectInfo';
 export * from './src/model/QualifierInfo';
+export * from './src/model/EggMultiInstancePrototypeInfo';
 
 export * from './src/util/MetadataUtil';
 export * from './src/util/PrototypeUtil';

core/core-decorator/src/decorator/MultiInstanceProto.ts

@@ -0,0 +1,73 @@
+import { ObjectInitType, ObjectInitTypeLike } from '../enum/ObjectInitType';
+import { AccessLevel } from '../enum/AccessLevel';
+import { DEFAULT_PROTO_IMPL_TYPE } from './Prototype';
+import {
+  EggMultiInstanceCallbackPrototypeInfo,
+  EggMultiInstancePrototypeInfo,
+  MultiInstancePrototypeGetObjectsContext,
+  ObjectInfo,
+} from '../model/EggMultiInstancePrototypeInfo';
+import { EggProtoImplClass } from '../model/EggPrototypeInfo';
+import { PrototypeUtil } from '../util/PrototypeUtil';
+import { StackUtil } from '@eggjs/tegg-common-util';
+
+const DEFAULT_PARAMS = {
+  initType: ObjectInitType.SINGLETON,
+  accessLevel: AccessLevel.PRIVATE,
+  protoImplType: DEFAULT_PROTO_IMPL_TYPE,
+};
+
+export interface BaseMultiInstancePrototypeCallbackParams {
+  /**
+   * obj init type
+   */
+  initType?: ObjectInitTypeLike;
+  /**
+   * access level
+   */
+  accessLevel?: AccessLevel;
+  /**
+   * EggPrototype implement type
+   */
+  protoImplType?: string;
+}
+
+export interface MultiInstancePrototypeCallbackParams extends BaseMultiInstancePrototypeCallbackParams {
+  getObjects(ctx: MultiInstancePrototypeGetObjectsContext): ObjectInfo[];
+}
+
+export interface MultiInstancePrototypeStaticParams extends BaseMultiInstancePrototypeCallbackParams {
+  /**
+   * object info list
+   */
+  objects: ObjectInfo[];
+}
+
+export type MultiInstancePrototypeParams = MultiInstancePrototypeCallbackParams | MultiInstancePrototypeStaticParams;
+
+export function MultiInstanceProto(param: MultiInstancePrototypeParams) {
+  return function(clazz: EggProtoImplClass) {
+    PrototypeUtil.setIsEggMultiInstancePrototype(clazz);
+    if ((param as MultiInstancePrototypeStaticParams).objects) {
+      const property: EggMultiInstancePrototypeInfo = {
+        ...DEFAULT_PARAMS,
+        ...param as MultiInstancePrototypeStaticParams,
+      };
+      PrototypeUtil.setMultiInstanceStaticProperty(clazz, property);
+    } else if ((param as MultiInstancePrototypeCallbackParams).getObjects) {
+      const property: EggMultiInstanceCallbackPrototypeInfo = {
+        ...DEFAULT_PARAMS,
+        ...param as MultiInstancePrototypeCallbackParams,
+      };
+      PrototypeUtil.setMultiInstanceCallbackProperty(clazz, property);
+    }
+
+
+    // './tegg/core/common-util/src/StackUtil.ts',
+    // './tegg/core/core-decorator/src/decorator/Prototype.ts',
+    // './tegg/core/core-decorator/node_modules/[email protected]@reflect-metadata/Reflect.js',
+    // './tegg/core/core-decorator/node_modules/[email protected]@reflect-metadata/Reflect.js',
+    // './tegg/core/core-decorator/test/fixtures/decators/CacheService.ts',
+    PrototypeUtil.setFilePath(clazz, StackUtil.getCalleeFromStack(false, 4));
+  };
+}

core/core-decorator/src/model/EggMultiInstancePrototypeInfo.ts

@@ -0,0 +1,54 @@
+import { ObjectInitTypeLike } from '../enum/ObjectInitType';
+import { AccessLevel } from '../enum/AccessLevel';
+import { EggPrototypeName } from './EggPrototypeInfo';
+import { QualifierInfo } from './QualifierInfo';
+
+export interface ObjectInfo {
+  name: EggPrototypeName;
+  qualifiers: QualifierInfo[];
+}
+
+export interface MultiInstancePrototypeGetObjectsContext {
+  unitPath: string;
+}
+
+export interface EggMultiInstancePrototypeInfo {
+  /**
+   * obj init type
+   */
+  initType: ObjectInitTypeLike;
+  /**
+   * access level
+   */
+  accessLevel: AccessLevel;
+  /**
+   * EggPrototype implement type
+   */
+  protoImplType: string;
+
+  /**
+   * object info list
+   */
+  objects: ObjectInfo[];
+}
+
+export interface EggMultiInstanceCallbackPrototypeInfo {
+  /**
+   * obj init type
+   */
+  initType: ObjectInitTypeLike;
+  /**
+   * access level
+   */
+  accessLevel: AccessLevel;
+  /**
+   * EggPrototype implement type
+   */
+  protoImplType: string;
+
+  /**
+   * get object callback
+   * @param ctx
+   */
+  getObjects(ctx: MultiInstancePrototypeGetObjectsContext): ObjectInfo[];
+}

core/core-decorator/src/model/EggPrototypeInfo.ts

@@ -1,5 +1,6 @@
 import { ObjectInitTypeLike } from '../enum/ObjectInitType';
 import { AccessLevel } from '../enum/AccessLevel';
+import { QualifierInfo } from './QualifierInfo';
 
 export type EggProtoImplClass<T = object> = new(...args: any[]) => T;
 export type EggPrototypeName = PropertyKey;
@@ -21,4 +22,8 @@ export interface EggPrototypeInfo {
    * EggPrototype implement type
    */
   protoImplType: string;
+  /**
+   * EggPrototype qualifiers
+   */
+  qualifiers?: QualifierInfo[];
 }