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

package/dist/index.js

@@ -0,0 +1,31 @@
+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";
+
+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 };

package/dist/model/HTTPControllerMeta.d.ts

@@ -0,0 +1,25 @@
+import { HTTPMethodMeta } from "./HTTPMethodMeta.js";
+import { ControllerMetadata, ControllerType, EggPrototypeName, MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/model/HTTPControllerMeta.d.ts
+declare class HTTPControllerMeta implements ControllerMetadata {
+  readonly protoName: EggPrototypeName;
+  readonly controllerName: string;
+  readonly className: string;
+  readonly type = ControllerType.HTTP;
+  readonly path?: string;
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly methods: readonly HTTPMethodMeta[];
+  readonly needAcl: boolean;
+  readonly aclCode?: string;
+  readonly hosts?: string[];
+  constructor(className: string, protoName: EggPrototypeName, controllerName: string, path: string | undefined, middlewares: MiddlewareFunc[], methods: HTTPMethodMeta[], needAcl: boolean, aclCode: string | undefined, hosts: string[] | undefined);
+  getMethodRealPath(method: HTTPMethodMeta): string;
+  getMethodHosts(method: HTTPMethodMeta): string[] | undefined;
+  getMethodName(method: HTTPMethodMeta): string;
+  getMethodMiddlewares(method: HTTPMethodMeta): MiddlewareFunc[];
+  hasMethodAcl(method: HTTPMethodMeta): boolean;
+  getMethodAcl(method: HTTPMethodMeta): string | undefined;
+}
+//#endregion
+export { HTTPControllerMeta };

package/dist/model/HTTPControllerMeta.js

@@ -0,0 +1,53 @@
+import "./HTTPMethodMeta.js";
+import { ControllerType } from "@eggjs/tegg-types";
+import path from "node:path";
+
+//#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
+export { HTTPControllerMeta };

package/dist/model/HTTPCookies.d.ts

@@ -0,0 +1,6 @@
+import { Cookies } from "@eggjs/cookies";
+
+//#region src/model/HTTPCookies.d.ts
+declare class HTTPCookies extends Cookies {}
+//#endregion
+export { HTTPCookies };

package/dist/model/HTTPCookies.js

@@ -0,0 +1,7 @@
+import { Cookies } from "@eggjs/cookies";
+
+//#region src/model/HTTPCookies.ts
+var HTTPCookies = class extends Cookies {};
+
+//#endregion
+export { HTTPCookies };

package/dist/model/HTTPMethodMeta.d.ts

@@ -0,0 +1,59 @@
+import { HTTPMethodEnum, HTTPParamType, MethodMeta, MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/model/HTTPMethodMeta.d.ts
+declare abstract class ParamMeta {
+  type: HTTPParamType;
+  abstract validate(httpPath: string): void;
+}
+declare class RequestParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  validate(): void;
+}
+declare class BodyParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  validate(): void;
+}
+declare class HeadersParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  validate(): void;
+}
+declare class QueryParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  name: string;
+  constructor(name: string);
+  validate(): void;
+}
+declare class QueriesParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  name: string;
+  constructor(name: string);
+  validate(): void;
+}
+declare class PathParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  name: string;
+  constructor(name: string);
+  validate(httpPath: string): void;
+}
+declare class CookiesParamMeta extends ParamMeta {
+  type: HTTPParamType;
+  validate(): void;
+}
+declare class HTTPMethodMeta implements MethodMeta {
+  readonly name: string;
+  readonly path: string;
+  readonly method: HTTPMethodEnum;
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly contextParamIndex: number | undefined;
+  readonly paramMap: Map<number, ParamMeta>;
+  readonly priority: number;
+  readonly needAcl: boolean;
+  readonly aclCode: string | undefined;
+  readonly hosts: string[] | undefined;
+  constructor(name: string, path: string, method: HTTPMethodEnum, middlewares: MiddlewareFunc[], contextParamIndex: number | undefined, paramTypeMap: Map<number, ParamMeta>, priority: number, needAcl: boolean, aclCode: string | undefined, hosts: string[] | undefined);
+}
+declare class ParamMetaUtil {
+  static createParam(type: HTTPParamType, name?: string): RequestParamMeta | BodyParamMeta | HeadersParamMeta | QueryParamMeta | QueriesParamMeta | PathParamMeta | CookiesParamMeta;
+}
+//#endregion
+export { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta };

package/dist/model/HTTPMethodMeta.js

@@ -0,0 +1,102 @@
+import { HTTPParamType } from "@eggjs/tegg-types";
+import pathToRegexp from "path-to-regexp";
+import assert from "node:assert";
+
+//#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, method, middlewares, contextParamIndex, paramTypeMap, priority, needAcl, aclCode, hosts) {
+		this.name = name;
+		this.path = path;
+		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
+export { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta };

package/dist/model/HTTPRequest.d.ts

@@ -0,0 +1,8 @@
+//#region src/model/HTTPRequest.d.ts
+declare const HTTPRequest_base: ObjectConstructor | {
+  new (input: RequestInfo | URL, init?: RequestInit): Request;
+  prototype: Request;
+};
+declare class HTTPRequest extends HTTPRequest_base {}
+//#endregion
+export { HTTPRequest };

package/dist/model/HTTPRequest.js

@@ -0,0 +1,5 @@
+//#region src/model/HTTPRequest.ts
+var HTTPRequest = class extends (Request || Object) {};
+
+//#endregion
+export { HTTPRequest };

package/dist/model/HTTPResponse.d.ts

@@ -0,0 +1,11 @@
+//#region src/model/HTTPResponse.d.ts
+declare const HTTPResponse_base: {
+  new (body?: BodyInit | null, init?: ResponseInit): Response;
+  prototype: Response;
+  error(): Response;
+  json(data: any, init?: ResponseInit): Response;
+  redirect(url: string | URL, status?: number): Response;
+} | ObjectConstructor;
+declare class HTTPResponse extends HTTPResponse_base {}
+//#endregion
+export { HTTPResponse };

package/dist/model/HTTPResponse.js

@@ -0,0 +1,5 @@
+//#region src/model/HTTPResponse.ts
+var HTTPResponse = class extends (Response || Object) {};
+
+//#endregion
+export { HTTPResponse };

package/dist/model/index.js

@@ -0,0 +1,7 @@
+import { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta } from "./HTTPMethodMeta.js";
+import { HTTPControllerMeta } from "./HTTPControllerMeta.js";
+import { HTTPCookies } from "./HTTPCookies.js";
+import { HTTPRequest } from "./HTTPRequest.js";
+import { HTTPResponse } from "./HTTPResponse.js";
+
+export {  };

package/dist/util/ControllerInfoUtil.d.ts

@@ -0,0 +1,20 @@
+import { ControllerTypeLike, EggProtoImplClass, IAdvice, MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/util/ControllerInfoUtil.d.ts
+declare class ControllerInfoUtil {
+  static addControllerMiddleware(middleware: MiddlewareFunc, clazz: EggProtoImplClass): void;
+  static addControllerAopMiddleware(middleware: EggProtoImplClass<IAdvice>, clazz: EggProtoImplClass): void;
+  static getControllerMiddlewares(clazz: EggProtoImplClass): MiddlewareFunc[];
+  static getControllerAopMiddlewares(clazz: EggProtoImplClass): EggProtoImplClass<IAdvice>[];
+  static setControllerType(clazz: EggProtoImplClass, controllerType: ControllerTypeLike): void;
+  static setControllerName(clazz: EggProtoImplClass, controllerName: string): void;
+  static getControllerName(clazz: EggProtoImplClass): string | undefined;
+  static getControllerType(clazz: EggProtoImplClass): ControllerTypeLike | undefined;
+  static setControllerAcl(code: string | undefined, clazz: EggProtoImplClass): void;
+  static hasControllerAcl(clazz: EggProtoImplClass): boolean;
+  static getControllerAcl(clazz: EggProtoImplClass): string | undefined;
+  static addControllerHosts(hosts: string[], clazz: EggProtoImplClass): void;
+  static getControllerHosts(clazz: EggProtoImplClass): string[] | undefined;
+}
+//#endregion
+export { ControllerInfoUtil };

package/dist/util/ControllerInfoUtil.js

@@ -0,0 +1,48 @@
+import { CONTROLLER_ACL, CONTROLLER_AOP_MIDDLEWARES, CONTROLLER_HOST, CONTROLLER_MIDDLEWARES, CONTROLLER_NAME, CONTROLLER_TYPE } from "@eggjs/tegg-types";
+import { MetadataUtil } from "@eggjs/core-decorator";
+
+//#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
+export { ControllerInfoUtil };

package/dist/util/ControllerMetadataUtil.d.ts

@@ -0,0 +1,9 @@
+import { ControllerMetadata, EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/util/ControllerMetadataUtil.d.ts
+declare class ControllerMetadataUtil {
+  static setControllerMetadata(clazz: EggProtoImplClass, metaData: ControllerMetadata): void;
+  static getControllerMetadata(clazz: EggProtoImplClass): ControllerMetadata | undefined;
+}
+//#endregion
+export { ControllerMetadataUtil };

package/dist/util/ControllerMetadataUtil.js

@@ -0,0 +1,21 @@
+import { ControllerMetaBuilderFactory } from "../builder/ControllerMetaBuilderFactory.js";
+import "../builder/index.js";
+import { CONTROLLER_META_DATA } from "@eggjs/tegg-types";
+import { MetadataUtil } from "@eggjs/core-decorator";
+
+//#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
+export { ControllerMetadataUtil };

package/dist/util/HTTPInfoUtil.d.ts

@@ -0,0 +1,20 @@
+import { EggProtoImplClass, HTTPMethodEnum, HTTPParamType } from "@eggjs/tegg-types";
+
+//#region src/util/HTTPInfoUtil.d.ts
+declare class HTTPInfoUtil {
+  static setHTTPPath(path: string, clazz: EggProtoImplClass): void;
+  static getHTTPPath(clazz: EggProtoImplClass): string | undefined;
+  static setHTTPMethodPath(path: string, clazz: EggProtoImplClass, methodName: string): void;
+  static getHTTPMethodPath(clazz: EggProtoImplClass, methodName: string): string | undefined;
+  static setHTTPMethodMethod(method: HTTPMethodEnum, clazz: EggProtoImplClass, methodName: string): void;
+  static getHTTPMethodMethod(clazz: EggProtoImplClass, methodName: string): HTTPMethodEnum | undefined;
+  static setHTTPMethodParamType(paramType: HTTPParamType, parameterIndex: number, clazz: EggProtoImplClass, methodName: string): void;
+  static getParamIndexList(clazz: EggProtoImplClass, methodName: string): number[];
+  static getHTTPMethodParamType(parameterIndex: number, clazz: EggProtoImplClass, methodName: string): HTTPParamType | undefined;
+  static setHTTPMethodParamName(paramName: string, parameterIndex: number, clazz: EggProtoImplClass, methodName: string): void;
+  static getHTTPMethodParamName(parameterIndex: number, clazz: EggProtoImplClass, methodName: string): string | undefined;
+  static getHTTPMethodPriority(clazz: EggProtoImplClass, methodName: string): number | undefined;
+  static setHTTPMethodPriority(priority: number, clazz: EggProtoImplClass, methodName: string): void;
+}
+//#endregion
+export { HTTPInfoUtil };

package/dist/util/HTTPInfoUtil.js

@@ -0,0 +1,53 @@
+import { CONTROLLER_HTTP_PATH, CONTROLLER_METHOD_METHOD_MAP, CONTROLLER_METHOD_PARAM_NAME_MAP, CONTROLLER_METHOD_PARAM_TYPE_MAP, CONTROLLER_METHOD_PATH_MAP, CONTROLLER_METHOD_PRIORITY } from "@eggjs/tegg-types";
+import { MetadataUtil } from "@eggjs/core-decorator";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#region src/util/HTTPInfoUtil.ts
+var HTTPInfoUtil = class {
+	static setHTTPPath(path, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_HTTP_PATH, path, clazz);
+	}
+	static getHTTPPath(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_HTTP_PATH, clazz);
+	}
+	static setHTTPMethodPath(path, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_METHOD_PATH_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, path);
+	}
+	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
+export { HTTPInfoUtil };

package/dist/util/HTTPPriorityUtil.d.ts

@@ -0,0 +1,22 @@
+//#region src/util/HTTPPriorityUtil.d.ts
+declare class HTTPPriorityUtil {
+  static readonly DEFAULT_PRIORITY = 100000;
+  private static readonly TOKEN_PRIORITY;
+  /**
+   * | 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: string): number;
+}
+//#endregion
+export { HTTPPriorityUtil };

package/dist/util/HTTPPriorityUtil.js

@@ -0,0 +1,38 @@
+import { parse } from "path-to-regexp";
+
+//#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) {
+		const tokens = parse(path);
+		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
+export { HTTPPriorityUtil };

package/dist/util/MethodInfoUtil.d.ts

@@ -0,0 +1,23 @@
+import { ControllerTypeLike, EggProtoImplClass, IAdvice, MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/util/MethodInfoUtil.d.ts
+declare class MethodInfoUtil {
+  static setMethodControllerType(clazz: EggProtoImplClass, methodName: string, controllerType: ControllerTypeLike): void;
+  static getMethodControllerType(clazz: EggProtoImplClass, methodName: string): ControllerTypeLike | undefined;
+  static setMethodContextIndexInArgs(index: number, clazz: EggProtoImplClass, methodName: string): void;
+  static getMethodContextIndex(clazz: EggProtoImplClass, methodName: string): number | undefined;
+  static addMethodMiddleware(middleware: MiddlewareFunc, clazz: EggProtoImplClass, methodName: string): void;
+  static getMethodMiddlewares(clazz: EggProtoImplClass, methodName: string): MiddlewareFunc[];
+  static addMethodAopMiddleware(middleware: EggProtoImplClass<IAdvice>, clazz: EggProtoImplClass, methodName: string): void;
+  static getMethodAopMiddlewares(clazz: EggProtoImplClass, methodName: string): EggProtoImplClass<IAdvice>[];
+  static setMethodAcl(code: string | undefined, clazz: EggProtoImplClass, methodName: string): void;
+  static hasMethodAcl(clazz: EggProtoImplClass, methodName: string): boolean;
+  static getMethodAcl(clazz: EggProtoImplClass, methodName: string): string | undefined;
+  static setMethodHosts(hosts: string[], clazz: EggProtoImplClass, methodName: string): void;
+  static getMethodHosts(clazz: EggProtoImplClass, methodName: string): string[] | undefined;
+  static getMethods(clazz: EggProtoImplClass): string[];
+  static shouldRegisterAopMiddlewarePointCut(clazz: EggProtoImplClass, methodName: string): boolean;
+  static registerAopMiddlewarePointcut(clazz: EggProtoImplClass, methodName: string): void;
+}
+//#endregion
+export { MethodInfoUtil };

package/dist/util/MethodInfoUtil.js

@@ -0,0 +1,62 @@
+import { 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 } from "@eggjs/core-decorator";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#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
+export { MethodInfoUtil };