@eggjs/controller-decorator 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/index.js

@@ -1,31 +1,752 @@
-import { ControllerInfoUtil } from "./util/ControllerInfoUtil.js";
-import { ControllerValidator } from "./util/validator/ControllerValidator.js";
-import { MethodInfoUtil } from "./util/MethodInfoUtil.js";
-import { MethodValidator } from "./util/validator/MethodValidator.js";
-import { ControllerMetadataUtil } from "./util/ControllerMetadataUtil.js";
-import { HTTPInfoUtil } from "./util/HTTPInfoUtil.js";
-import { HTTPPriorityUtil } from "./util/HTTPPriorityUtil.js";
-import "./util/index.js";
-import { ControllerMetaBuilderFactory } from "./builder/ControllerMetaBuilderFactory.js";
-import "./builder/index.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 "./decorator/index.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 "./model/index.js";
-import { HTTPControllerMethodMetaBuilder } from "./impl/http/HTTPControllerMethodMetaBuilder.js";
-import { HTTPControllerMetaBuilder } from "./impl/http/HTTPControllerMetaBuilder.js";
-import "./impl/index.js";
+import { AdviceInfoUtil, Pointcut } from "@eggjs/aop-decorator";
+import { ClassUtil } from "@eggjs/tegg-metadata";
+import { AccessLevel, CONTROLLER_ACL, CONTROLLER_AOP_MIDDLEWARES, CONTROLLER_HOST, CONTROLLER_HTTP_PATH, CONTROLLER_META_DATA, CONTROLLER_METHOD_METHOD_MAP, CONTROLLER_METHOD_PARAM_NAME_MAP, CONTROLLER_METHOD_PARAM_TYPE_MAP, CONTROLLER_METHOD_PATH_MAP, CONTROLLER_METHOD_PRIORITY, CONTROLLER_MIDDLEWARES, CONTROLLER_NAME, CONTROLLER_TYPE, ControllerType, HTTPParamType, METHOD_ACL, METHOD_AOP_MIDDLEWARES, METHOD_AOP_REGISTER_MAP, METHOD_CONTEXT_INDEX, METHOD_CONTROLLER_HOST, METHOD_CONTROLLER_TYPE_MAP, METHOD_MIDDLEWARES } from "@eggjs/tegg-types";
+import { MetadataUtil, PrototypeUtil, SingletonProto } from "@eggjs/core-decorator";
+import { MapUtil, ObjectUtils, StackUtil } from "@eggjs/tegg-common-util";
+import pathToRegexp, { parse } from "path-to-regexp";
+import assert from "node:assert";
+import { isClass } from "is-type-of";
+import path from "node:path";
+import { Cookies as Cookies$1 } from "@eggjs/cookies";
 
 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 };
+//#region src/util/ControllerInfoUtil.ts
+var ControllerInfoUtil = class {
+	static addControllerMiddleware(middleware, clazz) {
+		MetadataUtil.initOwnArrayMetaData(CONTROLLER_MIDDLEWARES, clazz, []).push(middleware);
+	}
+	static addControllerAopMiddleware(middleware, clazz) {
+		MetadataUtil.initOwnArrayMetaData(CONTROLLER_AOP_MIDDLEWARES, clazz, []).push(middleware);
+	}
+	static getControllerMiddlewares(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_MIDDLEWARES, clazz) || [];
+	}
+	static getControllerAopMiddlewares(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_AOP_MIDDLEWARES, clazz) || [];
+	}
+	static setControllerType(clazz, controllerType) {
+		MetadataUtil.defineMetaData(CONTROLLER_TYPE, controllerType, clazz);
+	}
+	static setControllerName(clazz, controllerName) {
+		MetadataUtil.defineMetaData(CONTROLLER_NAME, controllerName, clazz);
+	}
+	static getControllerName(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_NAME, clazz);
+	}
+	static getControllerType(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_TYPE, clazz);
+	}
+	static setControllerAcl(code, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_ACL, code, clazz);
+	}
+	static hasControllerAcl(clazz) {
+		return MetadataUtil.hasMetaData(CONTROLLER_ACL, clazz);
+	}
+	static getControllerAcl(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_ACL, clazz);
+	}
+	static addControllerHosts(hosts, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_HOST, hosts, clazz);
+	}
+	static getControllerHosts(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_HOST, clazz);
+	}
+};
+
+//#endregion
+//#region src/util/validator/ControllerValidator.ts
+var ControllerValidator = class {
+	static validate(clazz) {
+		const controllerType = ControllerInfoUtil.getControllerType(clazz);
+		if (ControllerInfoUtil.getControllerMiddlewares(clazz).length && !controllerType) {
+			const desc = ClassUtil.classDescription(clazz);
+			throw new Error(`${desc} @Middleware should use with controller decorator`);
+		}
+	}
+};
+
+//#endregion
+//#region src/util/MethodInfoUtil.ts
+var MethodInfoUtil = class {
+	static setMethodControllerType(clazz, methodName, controllerType) {
+		MetadataUtil.initOwnMapMetaData(METHOD_CONTROLLER_TYPE_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, controllerType);
+	}
+	static getMethodControllerType(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_CONTROLLER_TYPE_MAP, clazz)?.get(methodName);
+	}
+	static setMethodContextIndexInArgs(index, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(METHOD_CONTEXT_INDEX, clazz, /* @__PURE__ */ new Map()).set(methodName, index);
+	}
+	static getMethodContextIndex(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_CONTEXT_INDEX, clazz)?.get(methodName);
+	}
+	static addMethodMiddleware(middleware, clazz, methodName) {
+		const methodMiddlewareMap = MetadataUtil.initOwnMapMetaData(METHOD_MIDDLEWARES, clazz, /* @__PURE__ */ new Map());
+		MapUtil.getOrStore(methodMiddlewareMap, methodName, []).push(middleware);
+	}
+	static getMethodMiddlewares(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_MIDDLEWARES, clazz)?.get(methodName) || [];
+	}
+	static addMethodAopMiddleware(middleware, clazz, methodName) {
+		const methodMiddlewareMap = MetadataUtil.initOwnMapMetaData(METHOD_AOP_MIDDLEWARES, clazz, /* @__PURE__ */ new Map());
+		MapUtil.getOrStore(methodMiddlewareMap, methodName, []).push(middleware);
+	}
+	static getMethodAopMiddlewares(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_AOP_MIDDLEWARES, clazz)?.get(methodName) || [];
+	}
+	static setMethodAcl(code, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(METHOD_ACL, clazz, /* @__PURE__ */ new Map()).set(methodName, code);
+	}
+	static hasMethodAcl(clazz, methodName) {
+		return !!MetadataUtil.getMetaData(METHOD_ACL, clazz)?.has(methodName);
+	}
+	static getMethodAcl(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_ACL, clazz)?.get(methodName);
+	}
+	static setMethodHosts(hosts, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(METHOD_CONTROLLER_HOST, clazz, /* @__PURE__ */ new Map()).set(methodName, hosts);
+	}
+	static getMethodHosts(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_CONTROLLER_HOST, clazz)?.get(methodName);
+	}
+	static getMethods(clazz) {
+		const methodControllerMap = MetadataUtil.getMetaData(METHOD_CONTROLLER_TYPE_MAP, clazz);
+		return Array.from(methodControllerMap?.keys() || []);
+	}
+	static shouldRegisterAopMiddlewarePointCut(clazz, methodName) {
+		const methodControllerMap = MetadataUtil.getMetaData(METHOD_AOP_REGISTER_MAP, clazz);
+		return !(methodControllerMap && methodControllerMap.get(methodName));
+	}
+	static registerAopMiddlewarePointcut(clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(METHOD_AOP_REGISTER_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, true);
+	}
+};
+
+//#endregion
+//#region src/util/validator/MethodValidator.ts
+var MethodValidator = class {
+	static validate(clazz, methodName) {
+		const methodControllerType = MethodInfoUtil.getMethodControllerType(clazz, methodName);
+		const methodMiddlewares = MethodInfoUtil.getMethodMiddlewares(clazz, methodName);
+		const contextIndex = MethodInfoUtil.getMethodContextIndex(clazz, methodName);
+		if (!methodControllerType) {
+			if (methodMiddlewares.length) {
+				const desc = ClassUtil.classDescription(clazz);
+				throw new Error(`${desc}:${methodName} @Middleware should use with method decorator`);
+			}
+			if (contextIndex !== void 0) {
+				const desc = ClassUtil.classDescription(clazz);
+				throw new Error(`${desc}:${methodName} @Context should use with method decorator`);
+			}
+			return;
+		}
+		const controllerType = ControllerInfoUtil.getControllerType(clazz);
+		if (methodControllerType !== controllerType) {
+			const desc = ClassUtil.classDescription(clazz);
+			throw new Error(`${desc}:${methodName} method decorator ${methodControllerType} can not be used with ${controllerType}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/util/ControllerMetadataUtil.ts
+var ControllerMetadataUtil = class ControllerMetadataUtil {
+	static setControllerMetadata(clazz, metaData) {
+		MetadataUtil.defineMetaData(CONTROLLER_META_DATA, metaData, clazz);
+	}
+	static getControllerMetadata(clazz) {
+		let metadata = MetadataUtil.getOwnMetaData(CONTROLLER_META_DATA, clazz);
+		if (metadata) return metadata;
+		metadata = ControllerMetaBuilderFactory.build(clazz);
+		if (metadata) ControllerMetadataUtil.setControllerMetadata(clazz, metadata);
+		return metadata;
+	}
+};
+
+//#endregion
+//#region src/util/HTTPInfoUtil.ts
+var HTTPInfoUtil = class {
+	static setHTTPPath(path$1, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_HTTP_PATH, path$1, clazz);
+	}
+	static getHTTPPath(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_HTTP_PATH, clazz);
+	}
+	static setHTTPMethodPath(path$1, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_METHOD_PATH_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, path$1);
+	}
+	static getHTTPMethodPath(clazz, methodName) {
+		return MetadataUtil.getMetaData(CONTROLLER_METHOD_PATH_MAP, clazz)?.get(methodName);
+	}
+	static setHTTPMethodMethod(method, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_METHOD_METHOD_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, method);
+	}
+	static getHTTPMethodMethod(clazz, methodName) {
+		return MetadataUtil.getMetaData(CONTROLLER_METHOD_METHOD_MAP, clazz)?.get(methodName);
+	}
+	static setHTTPMethodParamType(paramType, parameterIndex, clazz, methodName) {
+		const methodParamMap = MetadataUtil.initOwnMapMetaData(CONTROLLER_METHOD_PARAM_TYPE_MAP, clazz, /* @__PURE__ */ new Map());
+		MapUtil.getOrStore(methodParamMap, methodName, /* @__PURE__ */ new Map()).set(parameterIndex, paramType);
+	}
+	static getParamIndexList(clazz, methodName) {
+		const paramMap = MetadataUtil.getMetaData(CONTROLLER_METHOD_PARAM_TYPE_MAP, clazz)?.get(methodName);
+		if (!paramMap) return [];
+		return Array.from(paramMap.keys());
+	}
+	static getHTTPMethodParamType(parameterIndex, clazz, methodName) {
+		return (MetadataUtil.getMetaData(CONTROLLER_METHOD_PARAM_TYPE_MAP, clazz)?.get(methodName))?.get(parameterIndex);
+	}
+	static setHTTPMethodParamName(paramName, parameterIndex, clazz, methodName) {
+		const methodParamNameMap = MetadataUtil.initOwnMapMetaData(CONTROLLER_METHOD_PARAM_NAME_MAP, clazz, /* @__PURE__ */ new Map());
+		MapUtil.getOrStore(methodParamNameMap, methodName, /* @__PURE__ */ new Map()).set(parameterIndex, paramName);
+	}
+	static getHTTPMethodParamName(parameterIndex, clazz, methodName) {
+		return (MetadataUtil.getMetaData(CONTROLLER_METHOD_PARAM_NAME_MAP, clazz)?.get(methodName))?.get(parameterIndex);
+	}
+	static getHTTPMethodPriority(clazz, methodName) {
+		return MetadataUtil.getMetaData(CONTROLLER_METHOD_PRIORITY, clazz)?.get(methodName);
+	}
+	static setHTTPMethodPriority(priority, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_METHOD_PRIORITY, clazz, /* @__PURE__ */ new Map()).set(methodName, priority);
+	}
+};
+
+//#endregion
+//#region src/util/HTTPPriorityUtil.ts
+var HTTPPriorityUtil = class {
+	static DEFAULT_PRIORITY = 1e5;
+	static TOKEN_PRIORITY = 1e3;
+	/**
+	* | Path | RegExp index | priority |
+	* | --- | --- | --- |
+	* | /* | [0] | 0 |
+	* | /hello/:name | [1] | 1000 |
+	* | /hello/world/message/:message | [3] | 3000 |
+	* | /hello/:name/message/:message | [1, 3] | 4000 |
+	* | /hello/world | [] | 100000/Infinity？ |
+	*
+	* priority = hasRegExp
+	*   : regexpIndex.reduce((p,c) => p + c * 1000, 0)
+	*   : 100000;
+	* @param {string} path -
+	*/
+	static calcPathPriority(path$1) {
+		const tokens = parse(path$1);
+		let priority = 0;
+		let hasRegExp = false;
+		let index = 0;
+		let token;
+		while (token = tokens.shift()) if (typeof token === "string") index += token.split("/").length - 1;
+		else {
+			hasRegExp = true;
+			priority += index++ * this.TOKEN_PRIORITY;
+		}
+		if (!hasRegExp) return this.DEFAULT_PRIORITY;
+		return priority;
+	}
+};
+
+//#endregion
+//#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
+//#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
+//#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
+//#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
+//#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$1() {
+	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
+//#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
+//#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
+//#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
+//#region src/model/HTTPMethodMeta.ts
+var ParamMeta = class {
+	type;
+};
+var RequestParamMeta = class extends ParamMeta {
+	type = HTTPParamType.REQUEST;
+	validate() {}
+};
+var BodyParamMeta = class extends ParamMeta {
+	type = HTTPParamType.BODY;
+	validate() {}
+};
+var HeadersParamMeta = class extends ParamMeta {
+	type = HTTPParamType.HEADERS;
+	validate() {}
+};
+var QueryParamMeta = class extends ParamMeta {
+	type = HTTPParamType.QUERY;
+	name;
+	constructor(name) {
+		super();
+		this.name = name;
+	}
+	validate() {}
+};
+var QueriesParamMeta = class extends ParamMeta {
+	type = HTTPParamType.QUERIES;
+	name;
+	constructor(name) {
+		super();
+		this.name = name;
+	}
+	validate() {}
+};
+var PathParamMeta = class extends ParamMeta {
+	type = HTTPParamType.PARAM;
+	name;
+	constructor(name) {
+		super();
+		this.name = name;
+	}
+	validate(httpPath) {
+		const names = [];
+		pathToRegexp(httpPath, names);
+		if (!names.find((name) => String(name.name) === this.name)) throw new Error(`can not find param ${this.name} in path ${httpPath}`);
+	}
+};
+var CookiesParamMeta = class extends ParamMeta {
+	type = HTTPParamType.COOKIES;
+	validate() {}
+};
+var HTTPMethodMeta = class {
+	name;
+	path;
+	method;
+	middlewares;
+	contextParamIndex;
+	paramMap;
+	priority;
+	needAcl;
+	aclCode;
+	hosts;
+	constructor(name, path$1, method, middlewares, contextParamIndex, paramTypeMap, priority, needAcl, aclCode, hosts) {
+		this.name = name;
+		this.path = path$1;
+		this.method = method;
+		this.middlewares = middlewares;
+		this.contextParamIndex = contextParamIndex;
+		this.paramMap = paramTypeMap;
+		this.priority = priority;
+		this.needAcl = needAcl;
+		this.aclCode = aclCode;
+		this.hosts = hosts;
+	}
+};
+var ParamMetaUtil = class {
+	static createParam(type, name) {
+		switch (type) {
+			case HTTPParamType.PARAM:
+				assert(name, "path param must has name");
+				return new PathParamMeta(name);
+			case HTTPParamType.BODY: return new BodyParamMeta();
+			case HTTPParamType.HEADERS: return new HeadersParamMeta();
+			case HTTPParamType.QUERIES:
+				assert(name, "queries param must has name");
+				return new QueriesParamMeta(name);
+			case HTTPParamType.QUERY:
+				assert(name, "query param must has name");
+				return new QueryParamMeta(name);
+			case HTTPParamType.REQUEST: return new RequestParamMeta();
+			case HTTPParamType.COOKIES: return new CookiesParamMeta();
+			default: assert.fail("never arrive");
+		}
+	}
+};
+
+//#endregion
+//#region src/model/HTTPControllerMeta.ts
+var HTTPControllerMeta = class {
+	protoName;
+	controllerName;
+	className;
+	type = ControllerType.HTTP;
+	path;
+	middlewares;
+	methods;
+	needAcl;
+	aclCode;
+	hosts;
+	constructor(className, protoName, controllerName, path$1, middlewares, methods, needAcl, aclCode, hosts) {
+		this.protoName = protoName;
+		this.controllerName = controllerName;
+		this.className = className;
+		this.path = path$1;
+		this.middlewares = middlewares;
+		this.methods = methods;
+		this.needAcl = needAcl;
+		this.aclCode = aclCode;
+		this.hosts = hosts;
+	}
+	getMethodRealPath(method) {
+		if (this.path) return path.posix.join(this.path, method.path);
+		return method.path;
+	}
+	getMethodHosts(method) {
+		if (this.hosts) return this.hosts;
+		return method.hosts;
+	}
+	getMethodName(method) {
+		return `${method.method} ${this.controllerName}.${method.name}`;
+	}
+	getMethodMiddlewares(method) {
+		if (this.middlewares.length) return [...this.middlewares, ...method.middlewares];
+		return [...method.middlewares];
+	}
+	hasMethodAcl(method) {
+		return method.needAcl || this.needAcl;
+	}
+	getMethodAcl(method) {
+		if (method.aclCode) return method.aclCode;
+		return this.aclCode;
+	}
+};
+
+//#endregion
+//#region src/model/HTTPCookies.ts
+var HTTPCookies = class extends Cookies$1 {};
+
+//#endregion
+//#region src/model/HTTPRequest.ts
+var HTTPRequest = class extends (Request || Object) {};
+
+//#endregion
+//#region src/model/HTTPResponse.ts
+var HTTPResponse = class extends (Response || Object) {};
+
+//#endregion
+//#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
+//#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 { 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$1 as Request, RequestParamMeta };