@eggjs/controller-decorator 4.0.0-beta.8 → 4.0.1-beta.0

package/README.md

@@ -14,4 +14,4 @@
 
 ## Usage
 
-Please read [@eggjs/tegg-controller-plugin](../../plugin/controller/README.md)
+Please read [@eggjs/controller-plugin](../../plugin/controller/README.md)

package/dist/builder/ControllerMetaBuilderFactory.d.ts

@@ -0,0 +1,11 @@
+import { ControllerMetaBuilder, ControllerMetaBuilderCreator, ControllerMetadata, ControllerTypeLike, EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/builder/ControllerMetaBuilderFactory.d.ts
+declare class ControllerMetaBuilderFactory {
+  private static builderCreatorMap;
+  static registerControllerMetaBuilder(controllerType: ControllerTypeLike, controllerBuilderCreator: ControllerMetaBuilderCreator): void;
+  static createControllerMetaBuilder(clazz: EggProtoImplClass, controllerType?: ControllerTypeLike): ControllerMetaBuilder | undefined;
+  static build(clazz: EggProtoImplClass, controllerType?: ControllerTypeLike): ControllerMetadata | undefined;
+}
+//#endregion
+export { ControllerMetaBuilderFactory };

package/dist/builder/ControllerMetaBuilderFactory.js

@@ -0,0 +1,37 @@
+import { ControllerInfoUtil } from "../util/ControllerInfoUtil.js";
+import { MethodInfoUtil } from "../util/MethodInfoUtil.js";
+import "../util/index.js";
+import { Pointcut } from "@eggjs/aop-decorator";
+
+//#region src/builder/ControllerMetaBuilderFactory.ts
+var ControllerMetaBuilderFactory = class ControllerMetaBuilderFactory {
+	static builderCreatorMap = /* @__PURE__ */ new Map();
+	static registerControllerMetaBuilder(controllerType, controllerBuilderCreator) {
+		this.builderCreatorMap.set(controllerType, controllerBuilderCreator);
+	}
+	static createControllerMetaBuilder(clazz, controllerType) {
+		if (!controllerType) controllerType = ControllerInfoUtil.getControllerType(clazz);
+		if (!controllerType) return;
+		const creator = this.builderCreatorMap.get(controllerType);
+		if (!creator) throw new Error(`not found controller meta builder for type ${controllerType}`);
+		return creator(clazz);
+	}
+	static build(clazz, controllerType) {
+		const builder = ControllerMetaBuilderFactory.createControllerMetaBuilder(clazz, controllerType);
+		if (!builder) return;
+		const metadata = builder.build();
+		if (!metadata) return;
+		const controllerAopMws = ControllerInfoUtil.getControllerAopMiddlewares(clazz);
+		for (const { name } of metadata.methods) {
+			const methodAopMws = MethodInfoUtil.getMethodAopMiddlewares(clazz, name);
+			if (MethodInfoUtil.shouldRegisterAopMiddlewarePointCut(clazz, name)) {
+				for (const mw of [...methodAopMws, ...controllerAopMws].reverse()) Pointcut(mw)(clazz.prototype, name);
+				MethodInfoUtil.registerAopMiddlewarePointcut(clazz, name);
+			}
+		}
+		return metadata;
+	}
+};
+
+//#endregion
+export { ControllerMetaBuilderFactory };

package/dist/builder/index.d.ts

@@ -0,0 +1 @@
+import { ControllerMetaBuilderFactory } from "./ControllerMetaBuilderFactory.js";

package/dist/builder/index.js

@@ -0,0 +1,3 @@
+import { ControllerMetaBuilderFactory } from "./ControllerMetaBuilderFactory.js";
+
+export {  };

package/dist/decorator/Acl.d.ts

@@ -0,0 +1,4 @@
+//#region src/decorator/Acl.d.ts
+declare function Acl(code?: string): (target: any, propertyKey?: PropertyKey) => void;
+//#endregion
+export { Acl };

package/dist/decorator/Acl.js

@@ -0,0 +1,24 @@
+import { ControllerInfoUtil } from "../util/ControllerInfoUtil.js";
+import { MethodInfoUtil } from "../util/MethodInfoUtil.js";
+import "../util/index.js";
+import assert from "node:assert";
+
+//#region src/decorator/Acl.ts
+function Acl(code) {
+	function classAcl(constructor) {
+		ControllerInfoUtil.setControllerAcl(code, constructor);
+	}
+	function methodAcl(target, propertyKey) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const controllerClazz = target.constructor;
+		const methodName = propertyKey;
+		MethodInfoUtil.setMethodAcl(code, controllerClazz, methodName);
+	}
+	return function(target, propertyKey) {
+		if (propertyKey === void 0) classAcl(target);
+		else methodAcl(target, propertyKey);
+	};
+}
+
+//#endregion
+export { Acl };

package/dist/decorator/Context.d.ts

@@ -0,0 +1,4 @@
+//#region src/decorator/Context.d.ts
+declare function InjectContext(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+//#endregion
+export { InjectContext };

package/dist/decorator/Context.js

@@ -0,0 +1,16 @@
+import { MethodInfoUtil } from "../util/MethodInfoUtil.js";
+import "../util/index.js";
+import assert from "node:assert";
+
+//#region src/decorator/Context.ts
+function InjectContext() {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		MethodInfoUtil.setMethodContextIndexInArgs(parameterIndex, controllerClazz, methodName);
+	};
+}
+
+//#endregion
+export { InjectContext };

package/dist/decorator/Middleware.d.ts

@@ -0,0 +1,6 @@
+import { EggProtoImplClass, IAdvice, MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/decorator/Middleware.d.ts
+declare function Middleware(...middlewares: Array<MiddlewareFunc> | Array<EggProtoImplClass<IAdvice>>): (target: any, propertyKey?: PropertyKey) => void;
+//#endregion
+export { Middleware };

package/dist/decorator/Middleware.js

@@ -0,0 +1,56 @@
+import { ControllerInfoUtil } from "../util/ControllerInfoUtil.js";
+import { MethodInfoUtil } from "../util/MethodInfoUtil.js";
+import "../util/index.js";
+import { AdviceInfoUtil } from "@eggjs/aop-decorator";
+import assert from "node:assert";
+import { isClass } from "is-type-of";
+
+//#region src/decorator/Middleware.ts
+const MiddlewareType = {
+	AOP: "AOP",
+	MiddlewareFunc: "MiddlewareFunc"
+};
+function isAop(mw) {
+	return isClass(mw) && AdviceInfoUtil.isAdvice(mw);
+}
+function isAopTypeOrMiddlewareType(middlewares) {
+	const adviceCount = middlewares.filter((t) => isAop(t)).length;
+	if (adviceCount) {
+		if (adviceCount === middlewares.length) return MiddlewareType.AOP;
+		throw new Error("AOP and MiddlewareFunc can not be mixed");
+	}
+	return MiddlewareType.MiddlewareFunc;
+}
+function Middleware(...middlewares) {
+	function functionTypeClassMiddleware(constructor) {
+		middlewares.forEach((mid) => {
+			ControllerInfoUtil.addControllerMiddleware(mid, constructor);
+		});
+	}
+	function aopTypeClassMiddleware(constructor) {
+		for (const aopAdvice of middlewares) ControllerInfoUtil.addControllerAopMiddleware(aopAdvice, constructor);
+	}
+	function functionTypeMethodMiddleware(target, propertyKey) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const controllerClazz = target.constructor;
+		const methodName = propertyKey;
+		middlewares.forEach((mid) => {
+			MethodInfoUtil.addMethodMiddleware(mid, controllerClazz, methodName);
+		});
+	}
+	function aopTypeMethodMiddleware(target, propertyKey) {
+		const controllerClazz = target.constructor;
+		const methodName = propertyKey;
+		for (const aopAdvice of middlewares) MethodInfoUtil.addMethodAopMiddleware(aopAdvice, controllerClazz, methodName);
+	}
+	return function(target, propertyKey) {
+		const type = isAopTypeOrMiddlewareType(middlewares);
+		if (propertyKey === void 0) if (type === MiddlewareType.AOP) aopTypeClassMiddleware(target);
+		else functionTypeClassMiddleware(target);
+		else if (type === MiddlewareType.AOP) aopTypeMethodMiddleware(target, propertyKey);
+		else functionTypeMethodMiddleware(target, propertyKey);
+	};
+}
+
+//#endregion
+export { Middleware };

package/dist/decorator/http/HTTPController.d.ts

@@ -0,0 +1,6 @@
+import { EggProtoImplClass, HTTPControllerParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/http/HTTPController.d.ts
+declare function HTTPController(param?: HTTPControllerParams): (constructor: EggProtoImplClass) => void;
+//#endregion
+export { HTTPController };

package/dist/decorator/http/HTTPController.js

@@ -0,0 +1,24 @@
+import { ControllerInfoUtil } from "../../util/ControllerInfoUtil.js";
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import "../../util/index.js";
+import { PrototypeUtil, SingletonProto } from "@eggjs/core-decorator";
+import { AccessLevel, ControllerType } from "@eggjs/tegg-types";
+import { StackUtil } from "@eggjs/tegg-common-util";
+
+//#region src/decorator/http/HTTPController.ts
+function HTTPController(param) {
+	return function(constructor) {
+		ControllerInfoUtil.setControllerType(constructor, ControllerType.HTTP);
+		if (param?.controllerName) ControllerInfoUtil.setControllerName(constructor, param.controllerName);
+		if (param?.path) HTTPInfoUtil.setHTTPPath(param.path, constructor);
+		if (param?.timeout) ControllerInfoUtil.setControllerTimeout(param.timeout, constructor);
+		SingletonProto({
+			accessLevel: AccessLevel.PUBLIC,
+			name: param?.protoName
+		})(constructor);
+		PrototypeUtil.setFilePath(constructor, StackUtil.getCalleeFromStack(false, 5));
+	};
+}
+
+//#endregion
+export { HTTPController };

package/dist/decorator/http/HTTPMethod.d.ts

@@ -0,0 +1,6 @@
+import { HTTPMethodParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/http/HTTPMethod.d.ts
+declare function HTTPMethod(param: HTTPMethodParams): (target: any, propertyKey: PropertyKey) => void;
+//#endregion
+export { HTTPMethod };

package/dist/decorator/http/HTTPMethod.js

@@ -0,0 +1,22 @@
+import { MethodInfoUtil } from "../../util/MethodInfoUtil.js";
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import "../../util/index.js";
+import { ControllerType } from "@eggjs/tegg-types";
+import assert from "node:assert";
+
+//#region src/decorator/http/HTTPMethod.ts
+function HTTPMethod(param) {
+	return function(target, propertyKey) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const controllerClazz = target.constructor;
+		const methodName = propertyKey;
+		MethodInfoUtil.setMethodControllerType(controllerClazz, methodName, ControllerType.HTTP);
+		HTTPInfoUtil.setHTTPMethodPath(param.path, controllerClazz, methodName);
+		HTTPInfoUtil.setHTTPMethodMethod(param.method, controllerClazz, methodName);
+		if (param.timeout) MethodInfoUtil.setMethodTimeout(param.timeout, controllerClazz, methodName);
+		if (param.priority !== void 0) HTTPInfoUtil.setHTTPMethodPriority(param.priority, controllerClazz, methodName);
+	};
+}
+
+//#endregion
+export { HTTPMethod };

package/dist/decorator/http/HTTPParam.d.ts

@@ -0,0 +1,159 @@
+import { InjectContext } from "../Context.js";
+import { HTTPParamParams, HTTPQueriesParams, HTTPQueryParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/http/HTTPParam.d.ts
+
+/**
+* Inject the request body.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPBody } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // POST /foo -H 'Content-Type: application/json' -d '{"foo": "bar"}'
+*   // body = { "foo": "bar" }
+*   async bar(@HTTPBody() body: any): Promise<void> {
+*     console.log(body);
+*   }
+* }
+* ```
+*/
+declare function HTTPBody(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+/**
+* Inject the request headers.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPHeaders, type IncomingHttpHeaders } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo -H 'X-Custom: custom'
+*   // headers['x-custom'] = 'custom'
+*   async bar(@HTTPHeaders() headers: IncomingHttpHeaders): Promise<void> {
+*     console.log(headers);
+*   }
+* }
+* ```
+*/
+declare function HTTPHeaders(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+/**
+* Inject the request query string, the value is string type.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPQuery } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo?user=asd
+*   // user = 'asd'
+*   async bar(@HTTPQuery() user?: string): Promise<void> {
+*     console.log(user);
+*   }
+* }
+* ```
+*/
+declare function HTTPQuery(param?: HTTPQueryParams): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+/**
+* Inject the request query strings, all value are Array type.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPQueries } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo?user=asd&user=fgh
+*   // user = ['asd', 'fgh']
+*   async bar(@HTTPQueries({ name: 'user' }) users?: string[]): Promise<void> {
+*     console.log(users);
+*   }
+* }
+* ```
+*/
+declare function HTTPQueries(param?: HTTPQueriesParams): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+/**
+* Inject the request path parameter, the value is string type.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo/:id',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo/123
+*   // id = '123'
+*   async bar(@HTTPParam() id: string): Promise<void> {
+*     console.log(id);
+*   }
+* }
+* ```
+*/
+declare function HTTPParam(param?: HTTPParamParams): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+/**
+* Inject the request object.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPRequest } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   async bar(@HTTPRequest() request: Request): Promise<void> {
+*     console.log(request);
+*   }
+* }
+* ```
+*/
+declare function HTTPRequest(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+/**
+* Inject the request cookies.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPCookies, type Cookies } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo -H 'Cookie: foo=bar; bar=baz'
+*   // cookies = cookies
+*   async bar(@HTTPCookies() cookies: Cookies): Promise<void> {
+*     console.log(cookies);
+*   }
+* }
+* ```
+*/
+declare function HTTPCookies(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+//#endregion
+export { HTTPBody, HTTPCookies, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, HTTPRequest };

package/dist/decorator/http/HTTPParam.js

@@ -0,0 +1,223 @@
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import "../../util/index.js";
+import { InjectContext } from "../Context.js";
+import { HTTPParamType } from "@eggjs/tegg-types";
+import { ObjectUtils } from "@eggjs/tegg-common-util";
+import assert from "node:assert";
+
+//#region src/decorator/http/HTTPParam.ts
+/**
+* Inject the request body.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPBody } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // POST /foo -H 'Content-Type: application/json' -d '{"foo": "bar"}'
+*   // body = { "foo": "bar" }
+*   async bar(@HTTPBody() body: any): Promise<void> {
+*     console.log(body);
+*   }
+* }
+* ```
+*/
+function HTTPBody() {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.BODY, parameterIndex, controllerClazz, methodName);
+	};
+}
+/**
+* Inject the request headers.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPHeaders, type IncomingHttpHeaders } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo -H 'X-Custom: custom'
+*   // headers['x-custom'] = 'custom'
+*   async bar(@HTTPHeaders() headers: IncomingHttpHeaders): Promise<void> {
+*     console.log(headers);
+*   }
+* }
+* ```
+*/
+function HTTPHeaders() {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.HEADERS, parameterIndex, controllerClazz, methodName);
+	};
+}
+/**
+* Inject the request query string, the value is string type.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPQuery } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo?user=asd
+*   // user = 'asd'
+*   async bar(@HTTPQuery() user?: string): Promise<void> {
+*     console.log(user);
+*   }
+* }
+* ```
+*/
+function HTTPQuery(param) {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		const argNames = ObjectUtils.getFunctionArgNameList(target[propertyKey]);
+		const name = param?.name || argNames[parameterIndex];
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.QUERY, parameterIndex, controllerClazz, methodName);
+		HTTPInfoUtil.setHTTPMethodParamName(name, parameterIndex, controllerClazz, methodName);
+	};
+}
+/**
+* Inject the request query strings, all value are Array type.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPQueries } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo?user=asd&user=fgh
+*   // user = ['asd', 'fgh']
+*   async bar(@HTTPQueries({ name: 'user' }) users?: string[]): Promise<void> {
+*     console.log(users);
+*   }
+* }
+* ```
+*/
+function HTTPQueries(param) {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		const argNames = ObjectUtils.getFunctionArgNameList(target[propertyKey]);
+		const name = param?.name || argNames[parameterIndex];
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.QUERIES, parameterIndex, controllerClazz, methodName);
+		HTTPInfoUtil.setHTTPMethodParamName(name, parameterIndex, controllerClazz, methodName);
+	};
+}
+/**
+* Inject the request path parameter, the value is string type.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPParam } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo/:id',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo/123
+*   // id = '123'
+*   async bar(@HTTPParam() id: string): Promise<void> {
+*     console.log(id);
+*   }
+* }
+* ```
+*/
+function HTTPParam(param) {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		const argNames = ObjectUtils.getFunctionArgNameList(target[propertyKey]);
+		const name = param?.name || argNames[parameterIndex];
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.PARAM, parameterIndex, controllerClazz, methodName);
+		HTTPInfoUtil.setHTTPMethodParamName(name, parameterIndex, controllerClazz, methodName);
+	};
+}
+/**
+* Inject the request object.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPRequest } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   async bar(@HTTPRequest() request: Request): Promise<void> {
+*     console.log(request);
+*   }
+* }
+* ```
+*/
+function HTTPRequest() {
+	return function(target, propertyKey, parameterIndex) {
+		const [nodeMajor] = process.versions.node.split(".").map((v) => Number(v));
+		assert(nodeMajor >= 16, `[controller/${target.name}] expect node version >=16, but now is ${nodeMajor}`);
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.REQUEST, parameterIndex, controllerClazz, methodName);
+	};
+}
+/**
+* Inject the request cookies.
+*
+* @example
+* ```typescript
+* import { HTTPController, HTTPMethod, HTTPMethodEnum, HTTPCookies, type Cookies } from 'egg';
+*
+* @HTTPController()
+* export class FooController {
+*   @HTTPMethod({
+*     path: '/foo',
+*     method: HTTPMethodEnum.GET,
+*   })
+*   // GET /foo -H 'Cookie: foo=bar; bar=baz'
+*   // cookies = cookies
+*   async bar(@HTTPCookies() cookies: Cookies): Promise<void> {
+*     console.log(cookies);
+*   }
+* }
+* ```
+*/
+function HTTPCookies() {
+	return function(target, propertyKey, parameterIndex) {
+		assert.equal(typeof propertyKey, "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const methodName = propertyKey;
+		const controllerClazz = target.constructor;
+		HTTPInfoUtil.setHTTPMethodParamType(HTTPParamType.COOKIES, parameterIndex, controllerClazz, methodName);
+	};
+}
+
+//#endregion
+export { HTTPBody, HTTPCookies, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, HTTPRequest };

package/dist/decorator/http/Host.d.ts

@@ -0,0 +1,6 @@
+import { HostType } from "@eggjs/tegg-types";
+
+//#region src/decorator/http/Host.d.ts
+declare function Host(host: HostType): (target: any, propertyKey?: PropertyKey) => void;
+//#endregion
+export { Host };

package/dist/decorator/http/Host.js

@@ -0,0 +1,27 @@
+import { ControllerInfoUtil } from "../../util/ControllerInfoUtil.js";
+import { MethodInfoUtil } from "../../util/MethodInfoUtil.js";
+import "../../util/index.js";
+import assert from "node:assert";
+
+//#region src/decorator/http/Host.ts
+function Host(host) {
+	function parseHost() {
+		return Array.isArray(host) ? host : [host];
+	}
+	function classHost(constructor) {
+		ControllerInfoUtil.addControllerHosts(parseHost(), constructor);
+	}
+	function methodHost(target, propertyKey) {
+		assert(typeof propertyKey === "string", `[controller/${target.name}] expect method name be typeof string, but now is ${String(propertyKey)}`);
+		const controllerClazz = target.constructor;
+		const methodName = propertyKey;
+		MethodInfoUtil.setMethodHosts(parseHost(), controllerClazz, methodName);
+	}
+	return function(target, propertyKey) {
+		if (propertyKey === void 0) classHost(target);
+		else methodHost(target, propertyKey);
+	};
+}
+
+//#endregion
+export { Host };

package/dist/decorator/http/index.d.ts

@@ -0,0 +1,5 @@
+import { Host } from "./Host.js";
+import { HTTPController } from "./HTTPController.js";
+import { HTTPMethod } from "./HTTPMethod.js";
+import { InjectContext } from "../Context.js";
+import { HTTPBody, HTTPCookies, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, HTTPRequest } from "./HTTPParam.js";