feat: impl Host decorator

Author: killagu

core/controller-decorator/index.ts

@@ -7,6 +7,7 @@ export * from './src/decorator/Acl';
 export * from './src/decorator/http/HTTPController';
 export * from './src/decorator/http/HTTPMethod';
 export * from './src/decorator/http/HTTPParam';
+export * from './src/decorator/http/Host';
 export * from './src/builder/ControllerMetaBuilderFactory';
 export * from './src/builder/ControllerMetaBuilder';
 export * from './src/util/ControllerMetadataUtil';

core/controller-decorator/src/decorator/http/Host.ts

@@ -0,0 +1,27 @@
+import ControllerInfoUtil from '../../util/ControllerInfoUtil';
+import { EggProtoImplClass } from '@eggjs/core-decorator';
+import MethodInfoUtil from '../../util/MethodInfoUtil';
+import assert from 'assert';
+
+export function Host(host: string) {
+  function classHost(constructor: EggProtoImplClass) {
+    ControllerInfoUtil.addControllerHost(host, constructor);
+  }
+
+  function methodHOst(target: any, propertyKey: PropertyKey) {
+    assert(typeof propertyKey === 'string',
+      `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+    const controllerClazz = target.constructor as EggProtoImplClass;
+    const methodName = propertyKey as string;
+
+    MethodInfoUtil.setMethodHost(host, controllerClazz, methodName);
+  }
+
+  return function(target: any, propertyKey?: PropertyKey) {
+    if (propertyKey === undefined) {
+      classHost(target);
+    } else {
+      methodHOst(target, propertyKey);
+    }
+  };
+}

core/controller-decorator/src/impl/http/HTTPControllerMetaBuilder.ts

@@ -43,8 +43,9 @@ export class HTTPControllerMetaBuilder {
     const protoName = property!.name as string;
     const needAcl = ControllerInfoUtil.hasControllerAcl(this.clazz);
     const aclCode = ControllerInfoUtil.getControllerAcl(this.clazz);
+    const host = ControllerInfoUtil.getControllerHost(this.clazz);
     const metadata = new HTTPControllerMeta(
-      clazzName, protoName, controllerName, httpPath, httpMiddlewares, methods, needAcl, aclCode);
+      clazzName, protoName, controllerName, httpPath, httpMiddlewares, methods, needAcl, aclCode, host);
     ControllerMetadataUtil.setControllerMetadata(this.clazz, metadata);
     for (const method of metadata.methods) {
       const realPath = metadata.getMethodRealPath(method);

core/controller-decorator/src/impl/http/HTTPControllerMethodMetaBuilder.ts

@@ -105,11 +105,13 @@ export class HTTPControllerMethodMetaBuilder {
     const middlewares = MethodInfoUtil.getMethodMiddlewares(this.clazz, this.methodName);
     const needAcl = MethodInfoUtil.hasMethodAcl(this.clazz, this.methodName);
     const aclCode = MethodInfoUtil.getMethodAcl(this.clazz, this.methodName);
+    const host = MethodInfoUtil.getMethodHost(this.clazz, this.methodName);
     const realPath = parentPath
       ? path.posix.join(parentPath, httpPath)
       : httpPath;
     const paramTypeMap = this.buildParamType(realPath);
     const priority = this.getPriority();
-    return new HTTPMethodMeta(this.methodName, httpPath!, httpMethod!, middlewares, contextIndex, paramTypeMap, priority, needAcl, aclCode);
+    return new HTTPMethodMeta(
+      this.methodName, httpPath!, httpMethod!, middlewares, contextIndex, paramTypeMap, priority, needAcl, aclCode, host);
   }
 }

core/controller-decorator/src/model/HTTPControllerMeta.ts

@@ -14,6 +14,7 @@ export class HTTPControllerMeta implements ControllerMetadata {
   public readonly methods: readonly HTTPMethodMeta[];
   public readonly needAcl: boolean;
   public readonly aclCode?: string;
+  public readonly host?: string;
 
   constructor(
     className: string,
@@ -24,6 +25,7 @@ export class HTTPControllerMeta implements ControllerMetadata {
     methods: HTTPMethodMeta[],
     needAcl: boolean,
     aclCode: string | undefined,
+    host: string | undefined,
   ) {
     this.protoName = protoName;
     this.controllerName = controllerName;
@@ -33,6 +35,7 @@ export class HTTPControllerMeta implements ControllerMetadata {
     this.methods = methods;
     this.needAcl = needAcl;
     this.aclCode = aclCode;
+    this.host = host;
   }
 
   getMethodRealPath(method: HTTPMethodMeta) {
@@ -42,6 +45,13 @@ export class HTTPControllerMeta implements ControllerMetadata {
     return method.path;
   }
 
+  getMethodHost(method: HTTPMethodMeta): string | undefined {
+    if (this.host) {
+      return this.host;
+    }
+    return method.host;
+  }
+
   getMethodName(method: HTTPMethodMeta) {
     return `${method.method} ${this.controllerName}.${method.name}`;
   }

core/controller-decorator/src/model/HTTPMethodMeta.ts

@@ -73,6 +73,7 @@ export class HTTPMethodMeta implements MethodMeta {
   public readonly priority: number;
   public readonly needAcL: boolean;
   public readonly aclCode: string | undefined;
+  public readonly host: string | undefined;
 
   constructor(
     name: string,
@@ -84,6 +85,7 @@ export class HTTPMethodMeta implements MethodMeta {
     priority: number,
     needAcl: boolean,
     aclCode: string | undefined,
+    host: string | undefined,
   ) {
     this.name = name;
     this.path = path;
@@ -94,6 +96,7 @@ export class HTTPMethodMeta implements MethodMeta {
     this.priority = priority;
     this.needAcL = needAcl;
     this.aclCode = aclCode;
+    this.host = host;
   }
 }
 

core/controller-decorator/src/util/ControllerInfoUtil.ts

@@ -3,6 +3,7 @@ import { EggProtoImplClass, MetadataUtil } from '@eggjs/core-decorator';
 
 export const CONTROLLER_TYPE = Symbol.for('EggPrototype#controllerType');
 export const CONTROLLER_NAME = Symbol.for('EggPrototype#controllerName');
+export const CONTROLLER_HOST = Symbol.for('EggPrototype#controllerHost');
 export const CONTROLLER_MIDDLEWARES = Symbol.for('EggPrototype#controller#middlewares');
 export const CONTROLLER_ACL = Symbol.for('EggPrototype#controller#acl');
 
@@ -43,4 +44,12 @@ export default class ControllerInfoUtil {
   static getControllerAcl(clazz: EggProtoImplClass): string | undefined {
     return MetadataUtil.getMetaData(CONTROLLER_ACL, clazz);
   }
+
+  static addControllerHost(host: string, clazz: EggProtoImplClass) {
+    MetadataUtil.defineMetaData(CONTROLLER_HOST, host, clazz);
+  }
+
+  static getControllerHost(clazz: EggProtoImplClass): string | undefined {
+    return MetadataUtil.getMetaData(CONTROLLER_HOST, clazz);
+  }
 }

core/controller-decorator/src/util/MethodInfoUtil.ts

@@ -3,6 +3,7 @@ import { ControllerTypeLike, MiddlewareFunc } from '../model';
 import { MapUtil } from '@eggjs/tegg-common-util';
 
 const METHOD_CONTROLLER_TYPE_MAP = Symbol.for('EggPrototype#controller#mthods');
+const METHOD_CONTROLLER_HOST = Symbol.for('EggPrototype#controller#mthods#host');
 const METHOD_CONTEXT_INDEX = Symbol.for('EggPrototype#controller#method#context');
 const METHOD_MIDDLEWARES = Symbol.for('EggPrototype#method#middlewares');
 const METHOD_ACL = Symbol.for('EggPrototype#method#acl');
@@ -58,4 +59,14 @@ export default class MethodInfoUtil {
     const methodAclMap: MethodAclMap | undefined = MetadataUtil.getMetaData(METHOD_ACL, clazz);
     return methodAclMap?.get(methodName);
   }
+
+  static setMethodHost(host: string, clazz: EggProtoImplClass, methodName: string) {
+    const methodControllerMap: METHOD_MAP = MetadataUtil.initOwnMapMetaData(METHOD_CONTROLLER_HOST, clazz, new Map());
+    methodControllerMap.set(methodName, host);
+  }
+
+  static getMethodHost(clazz: EggProtoImplClass, methodName: string): string | undefined {
+    const methodControllerMap: METHOD_MAP | undefined = MetadataUtil.getMetaData(METHOD_CONTROLLER_HOST, clazz);
+    return methodControllerMap?.get(methodName);
+  }
 }

core/controller-decorator/test/fixtures/HostController.ts

@@ -0,0 +1,13 @@
+import { Host } from '../../src/decorator/http/Host';
+
+@Host('foo.eggjs.com')
+export class HostController {
+  async hello(): Promise<void> {
+    return;
+  }
+
+  @Host('bar.eggjs.com')
+  async bar(): Promise<void> {
+    return;
+  }
+}

core/controller-decorator/test/http/Host.test.ts

@@ -0,0 +1,16 @@
+import assert from 'assert';
+import { HostController } from '../fixtures/HostController';
+import ControllerInfoUtil from '../../src/util/ControllerInfoUtil';
+import MethodInfoUtil from '../../src/util/MethodInfoUtil';
+
+describe('test/Host.test.ts', () => {
+  it('controller Host work', () => {
+    const controllerHost = ControllerInfoUtil.getControllerHost(HostController);
+    assert(controllerHost === 'foo.eggjs.com');
+  });
+
+  it('method Host work', () => {
+    const methodHost = MethodInfoUtil.getMethodHost(HostController, 'bar');
+    assert(methodHost === 'bar.eggjs.com');
+  });
+});