@eggjs/controller-decorator 4.0.0-beta.4 → 4.0.0-beta.5

package/README.md

@@ -1,5 +1,17 @@
 # @eggjs/controller-decorator
 
+[![NPM version][npm-image]][npm-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![npm download][download-image]][download-url]
+[![Node.js Version](https://img.shields.io/node/v/@eggjs/controller-decorator.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/controller-decorator.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/controller-decorator
+[snyk-image]: https://snyk.io/test/npm/@eggjs/controller-decorator/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/controller-decorator
+[download-image]: https://img.shields.io/npm/dm/@eggjs/controller-decorator.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/controller-decorator
+
 ## Usage
 
 Please read [@eggjs/tegg-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.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 Context(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+//#endregion
+export { Context };

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 Context() {
+	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 { Context };

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,57 @@
+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
+var MiddlewareType = /* @__PURE__ */ function(MiddlewareType$1) {
+	MiddlewareType$1["AOP"] = "AOP";
+	MiddlewareType$1["MiddlewareFunc"] = "MiddlewareFunc";
+	return MiddlewareType$1;
+}(MiddlewareType || {});
+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,23 @@
+import { ControllerInfoUtil } from "../../util/ControllerInfoUtil.js";
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import "../../util/index.js";
+import { AccessLevel, ControllerType } from "@eggjs/tegg-types";
+import { PrototypeUtil, SingletonProto } from "@eggjs/core-decorator";
+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);
+		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,21 @@
+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.priority !== void 0) HTTPInfoUtil.setHTTPMethodPriority(param.priority, controllerClazz, methodName);
+	};
+}
+
+//#endregion
+export { HTTPMethod };

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

@@ -0,0 +1,12 @@
+import { HTTPParamParams, HTTPQueriesParams, HTTPQueryParams } from "@eggjs/tegg-types";
+
+//#region src/decorator/http/HTTPParam.d.ts
+declare function HTTPBody(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+declare function HTTPHeaders(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+declare function HTTPQuery(param?: HTTPQueryParams): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+declare function HTTPQueries(param?: HTTPQueriesParams): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+declare function HTTPParam(param?: HTTPParamParams): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+declare function Request(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+declare function Cookies(): (target: any, propertyKey: PropertyKey, parameterIndex: number) => void;
+//#endregion
+export { Cookies, HTTPBody, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, Request };

package/dist/decorator/http/HTTPParam.js

@@ -0,0 +1,77 @@
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import "../../util/index.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
+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);
+	};
+}
+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);
+	};
+}
+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);
+	};
+}
+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);
+	};
+}
+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);
+	};
+}
+function Request() {
+	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);
+	};
+}
+function Cookies() {
+	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 { Cookies, HTTPBody, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, Request };

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.js

@@ -0,0 +1,6 @@
+import { Host } from "./Host.js";
+import { HTTPController } from "./HTTPController.js";
+import { HTTPMethod } from "./HTTPMethod.js";
+import { Cookies, HTTPBody, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, Request } from "./HTTPParam.js";
+
+export {  };

package/dist/decorator/index.js

@@ -0,0 +1,10 @@
+import { Host } from "./http/Host.js";
+import { HTTPController } from "./http/HTTPController.js";
+import { HTTPMethod } from "./http/HTTPMethod.js";
+import { Cookies, HTTPBody, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, Request } from "./http/HTTPParam.js";
+import "./http/index.js";
+import { Acl } from "./Acl.js";
+import { Context } from "./Context.js";
+import { Middleware } from "./Middleware.js";
+
+export {  };

package/dist/impl/http/HTTPControllerMetaBuilder.d.ts

@@ -0,0 +1,13 @@
+import { HTTPControllerMeta } from "../../model/HTTPControllerMeta.js";
+import { EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/impl/http/HTTPControllerMetaBuilder.d.ts
+declare class HTTPControllerMetaBuilder {
+  private readonly clazz;
+  constructor(clazz: EggProtoImplClass);
+  private buildMethod;
+  build(): HTTPControllerMeta;
+  static create(clazz: EggProtoImplClass): HTTPControllerMetaBuilder;
+}
+//#endregion
+export { HTTPControllerMetaBuilder };

package/dist/impl/http/HTTPControllerMetaBuilder.js

@@ -0,0 +1,63 @@
+import { ControllerInfoUtil } from "../../util/ControllerInfoUtil.js";
+import { ControllerValidator } from "../../util/validator/ControllerValidator.js";
+import { ControllerMetadataUtil } from "../../util/ControllerMetadataUtil.js";
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import "../../util/index.js";
+import { ControllerMetaBuilderFactory } from "../../builder/ControllerMetaBuilderFactory.js";
+import "../../builder/index.js";
+import { HTTPControllerMeta } from "../../model/HTTPControllerMeta.js";
+import "../../model/index.js";
+import { HTTPControllerMethodMetaBuilder } from "./HTTPControllerMethodMetaBuilder.js";
+import { ClassUtil } from "@eggjs/tegg-metadata";
+import { ControllerType } from "@eggjs/tegg-types";
+import { PrototypeUtil } from "@eggjs/core-decorator";
+import { ObjectUtils } from "@eggjs/tegg-common-util";
+import assert from "node:assert";
+
+//#region src/impl/http/HTTPControllerMetaBuilder.ts
+var HTTPControllerMetaBuilder = class HTTPControllerMetaBuilder {
+	clazz;
+	constructor(clazz) {
+		this.clazz = clazz;
+	}
+	buildMethod() {
+		const methodNames = ObjectUtils.getProperties(this.clazz.prototype);
+		const methods = [];
+		for (const methodName of methodNames) {
+			const methodMeta = new HTTPControllerMethodMetaBuilder(this.clazz, methodName).build();
+			if (methodMeta) methods.push(methodMeta);
+		}
+		return methods;
+	}
+	build() {
+		ControllerValidator.validate(this.clazz);
+		const controllerType = ControllerInfoUtil.getControllerType(this.clazz);
+		assert.equal(controllerType, ControllerType.HTTP, "invalidate controller type");
+		const httpPath = HTTPInfoUtil.getHTTPPath(this.clazz);
+		const httpMiddlewares = ControllerInfoUtil.getControllerMiddlewares(this.clazz);
+		const methods = this.buildMethod();
+		const clazzName = this.clazz.name;
+		const controllerName = ControllerInfoUtil.getControllerName(this.clazz) || clazzName;
+		const protoName = PrototypeUtil.getProperty(this.clazz).name;
+		const needAcl = ControllerInfoUtil.hasControllerAcl(this.clazz);
+		const aclCode = ControllerInfoUtil.getControllerAcl(this.clazz);
+		const hosts = ControllerInfoUtil.getControllerHosts(this.clazz);
+		const metadata = new HTTPControllerMeta(clazzName, protoName, controllerName, httpPath, httpMiddlewares, methods, needAcl, aclCode, hosts);
+		ControllerMetadataUtil.setControllerMetadata(this.clazz, metadata);
+		for (const method of metadata.methods) {
+			const realPath = metadata.getMethodRealPath(method);
+			if (!realPath.startsWith("/")) {
+				const desc = ClassUtil.classDescription(this.clazz);
+				throw new Error(`class ${desc} method ${method.name} path ${realPath} not start with /`);
+			}
+		}
+		return metadata;
+	}
+	static create(clazz) {
+		return new HTTPControllerMetaBuilder(clazz);
+	}
+};
+ControllerMetaBuilderFactory.registerControllerMetaBuilder(ControllerType.HTTP, HTTPControllerMetaBuilder.create);
+
+//#endregion
+export { HTTPControllerMetaBuilder };

package/dist/impl/http/HTTPControllerMethodMetaBuilder.d.ts

@@ -0,0 +1,15 @@
+import { HTTPMethodMeta } from "../../model/HTTPMethodMeta.js";
+import { EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/impl/http/HTTPControllerMethodMetaBuilder.d.ts
+declare class HTTPControllerMethodMetaBuilder {
+  private readonly clazz;
+  private readonly methodName;
+  constructor(clazz: EggProtoImplClass, methodName: string);
+  private checkParamDecorators;
+  private buildParamType;
+  getPriority(): number;
+  build(): HTTPMethodMeta | undefined;
+}
+//#endregion
+export { HTTPControllerMethodMetaBuilder };

package/dist/impl/http/HTTPControllerMethodMetaBuilder.js

@@ -0,0 +1,80 @@
+import { MethodInfoUtil } from "../../util/MethodInfoUtil.js";
+import { MethodValidator } from "../../util/validator/MethodValidator.js";
+import { HTTPInfoUtil } from "../../util/HTTPInfoUtil.js";
+import { HTTPPriorityUtil } from "../../util/HTTPPriorityUtil.js";
+import "../../util/index.js";
+import { HTTPMethodMeta, ParamMetaUtil } from "../../model/HTTPMethodMeta.js";
+import "../../model/index.js";
+import { ClassUtil } from "@eggjs/tegg-metadata";
+import path from "node:path";
+
+//#region src/impl/http/HTTPControllerMethodMetaBuilder.ts
+var HTTPControllerMethodMetaBuilder = class {
+	clazz;
+	methodName;
+	constructor(clazz, methodName) {
+		this.clazz = clazz;
+		this.methodName = methodName;
+	}
+	checkParamDecorators() {
+		const functionLength = this.clazz.prototype[this.methodName].length;
+		const paramIndexList = HTTPInfoUtil.getParamIndexList(this.clazz, this.methodName);
+		const contextIndex = MethodInfoUtil.getMethodContextIndex(this.clazz, this.methodName);
+		const hasAnnotationParamCount = typeof contextIndex === "undefined" ? paramIndexList.length : paramIndexList.length + 1;
+		const maxParamCount = Math.max(functionLength, hasAnnotationParamCount);
+		for (let i = 0; i < maxParamCount; ++i) {
+			if (i === contextIndex) continue;
+			if (!HTTPInfoUtil.getHTTPMethodParamType(i, this.clazz, this.methodName)) {
+				const classDesc = ClassUtil.classDescription(this.clazz);
+				throw new Error(`${classDesc}:${this.methodName} param ${i} has no http param type, Please add @HTTPBody, @HTTPParam, @HTTPQuery, @HTTPQueries`);
+			}
+		}
+	}
+	buildParamType(httpPath) {
+		this.checkParamDecorators();
+		const paramTypeMap = /* @__PURE__ */ new Map();
+		const paramIndexList = HTTPInfoUtil.getParamIndexList(this.clazz, this.methodName);
+		for (const paramIndex of paramIndexList) {
+			const paramType = HTTPInfoUtil.getHTTPMethodParamType(paramIndex, this.clazz, this.methodName);
+			const paramName = HTTPInfoUtil.getHTTPMethodParamName(paramIndex, this.clazz, this.methodName);
+			const paramMeta = ParamMetaUtil.createParam(paramType, paramName);
+			try {
+				paramMeta.validate(httpPath);
+			} catch (e) {
+				e.message = `build controller ${ClassUtil.classDescription(this.clazz)} method ${this.methodName} param ${paramName} failed: ${e.message}`;
+				throw e;
+			}
+			paramTypeMap.set(paramIndex, paramMeta);
+		}
+		return paramTypeMap;
+	}
+	getPriority() {
+		const priority = HTTPInfoUtil.getHTTPMethodPriority(this.clazz, this.methodName);
+		if (priority !== void 0) return priority;
+		const controllerPath = HTTPInfoUtil.getHTTPPath(this.clazz);
+		const methodPath = HTTPInfoUtil.getHTTPMethodPath(this.clazz, this.methodName);
+		const realPath = controllerPath ? path.posix.join(controllerPath, methodPath) : methodPath;
+		const defaultPriority = HTTPPriorityUtil.calcPathPriority(realPath);
+		if (defaultPriority > HTTPPriorityUtil.DEFAULT_PRIORITY) throw new Error(`path ${realPath} is too long, should set priority manually`);
+		return defaultPriority;
+	}
+	build() {
+		MethodValidator.validate(this.clazz, this.methodName);
+		if (!MethodInfoUtil.getMethodControllerType(this.clazz, this.methodName)) return;
+		const httpMethod = HTTPInfoUtil.getHTTPMethodMethod(this.clazz, this.methodName);
+		const parentPath = HTTPInfoUtil.getHTTPPath(this.clazz);
+		const httpPath = HTTPInfoUtil.getHTTPMethodPath(this.clazz, this.methodName);
+		const contextIndex = MethodInfoUtil.getMethodContextIndex(this.clazz, this.methodName);
+		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 hosts = MethodInfoUtil.getMethodHosts(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, hosts);
+	}
+};
+
+//#endregion
+export { HTTPControllerMethodMetaBuilder };

package/dist/impl/http/index.js

@@ -0,0 +1,4 @@
+import { HTTPControllerMethodMetaBuilder } from "./HTTPControllerMethodMetaBuilder.js";
+import { HTTPControllerMetaBuilder } from "./HTTPControllerMetaBuilder.js";
+
+export {  };

package/dist/impl/index.js

@@ -0,0 +1,5 @@
+import { HTTPControllerMethodMetaBuilder } from "./http/HTTPControllerMethodMetaBuilder.js";
+import { HTTPControllerMetaBuilder } from "./http/HTTPControllerMetaBuilder.js";
+import "./http/index.js";
+
+export {  };

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { ControllerMetaBuilderFactory } from "./builder/ControllerMetaBuilderFactory.js";
+import { Host } from "./decorator/http/Host.js";
+import { HTTPController } from "./decorator/http/HTTPController.js";
+import { HTTPMethod } from "./decorator/http/HTTPMethod.js";
+import { Cookies, HTTPBody, HTTPHeaders, HTTPParam, HTTPQueries, HTTPQuery, Request } from "./decorator/http/HTTPParam.js";
+import { Acl } from "./decorator/Acl.js";
+import { Context } from "./decorator/Context.js";
+import { Middleware } from "./decorator/Middleware.js";
+import { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta } from "./model/HTTPMethodMeta.js";
+import { HTTPControllerMeta } from "./model/HTTPControllerMeta.js";
+import { HTTPCookies } from "./model/HTTPCookies.js";
+import { HTTPRequest } from "./model/HTTPRequest.js";
+import { HTTPResponse } from "./model/HTTPResponse.js";
+import { HTTPControllerMetaBuilder } from "./impl/http/HTTPControllerMetaBuilder.js";
+import { HTTPControllerMethodMetaBuilder } from "./impl/http/HTTPControllerMethodMetaBuilder.js";
+import { ControllerValidator } from "./util/validator/ControllerValidator.js";
+import { MethodValidator } from "./util/validator/MethodValidator.js";
+import { ControllerInfoUtil } from "./util/ControllerInfoUtil.js";
+import { ControllerMetadataUtil } from "./util/ControllerMetadataUtil.js";
+import { HTTPInfoUtil } from "./util/HTTPInfoUtil.js";
+import { HTTPPriorityUtil } from "./util/HTTPPriorityUtil.js";
+import { MethodInfoUtil } from "./util/MethodInfoUtil.js";
+export * from "@eggjs/tegg-types/controller-decorator";
+export { Acl, BodyParamMeta, Context, ControllerInfoUtil, ControllerMetaBuilderFactory, ControllerMetadataUtil, ControllerValidator, Cookies, CookiesParamMeta, HTTPBody, HTTPController, HTTPControllerMeta, HTTPControllerMetaBuilder, HTTPControllerMethodMetaBuilder, HTTPCookies, HTTPHeaders, HTTPInfoUtil, HTTPMethod, HTTPMethodMeta, HTTPParam, HTTPPriorityUtil, HTTPQueries, HTTPQuery, HTTPRequest, HTTPResponse, HeadersParamMeta, Host, MethodInfoUtil, MethodValidator, Middleware, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, Request, RequestParamMeta };