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

package/dist/model/HTTPControllerMeta.d.ts

@@ -0,0 +1,27 @@
+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;
+  readonly path?: string;
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly methods: readonly HTTPMethodMeta[];
+  readonly needAcl: boolean;
+  readonly aclCode?: string;
+  readonly hosts?: string[];
+  readonly timeout?: number;
+  constructor(className: string, protoName: EggPrototypeName, controllerName: string, path: string | undefined, middlewares: MiddlewareFunc[], methods: HTTPMethodMeta[], needAcl: boolean, aclCode: string | undefined, hosts: string[] | undefined, timeout: number | 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;
+  getMethodTimeout(method: HTTPMethodMeta): number | undefined;
+}
+//#endregion
+export { HTTPControllerMeta };

package/dist/model/HTTPControllerMeta.js

@@ -0,0 +1,58 @@
+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;
+	timeout;
+	constructor(className, protoName, controllerName, path$1, middlewares, methods, needAcl, aclCode, hosts, timeout) {
+		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;
+		this.timeout = timeout;
+	}
+	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;
+	}
+	getMethodTimeout(method) {
+		return method.timeout || this.timeout;
+	}
+};
+
+//#endregion
+export { HTTPControllerMeta };

package/dist/model/HTTPCookies.d.ts

@@ -0,0 +1,2 @@
+import { Cookies } from "@eggjs/cookies";
+export { Cookies };

package/dist/model/HTTPCookies.js

@@ -0,0 +1,3 @@
+import { Cookies } from "@eggjs/cookies";
+
+export { Cookies };

package/dist/model/HTTPMethodMeta.d.ts

@@ -0,0 +1,60 @@
+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;
+  readonly timeout: number | 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, timeout: number | undefined);
+}
+declare class ParamMetaUtil {
+  static createParam(type: HTTPParamType, name?: string): ParamMeta;
+}
+//#endregion
+export { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta };

package/dist/model/HTTPMethodMeta.js

@@ -0,0 +1,104 @@
+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;
+	timeout;
+	constructor(name, path, method, middlewares, contextParamIndex, paramTypeMap, priority, needAcl, aclCode, hosts, timeout) {
+		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;
+		this.timeout = timeout;
+	}
+};
+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/HTTPResponse.d.ts

@@ -0,0 +1,7 @@
+//#region src/model/HTTPResponse.d.ts
+declare const HTTPResponseBase: {
+  new (): any;
+};
+declare class HTTPResponse extends HTTPResponseBase {}
+//#endregion
+export { HTTPResponse };

package/dist/model/HTTPResponse.js

@@ -0,0 +1,6 @@
+//#region src/model/HTTPResponse.ts
+const HTTPResponseBase = typeof Response !== "undefined" ? Response : Object;
+var HTTPResponse = class extends HTTPResponseBase {};
+
+//#endregion
+export { HTTPResponse };

package/dist/model/MCPControllerMeta.d.ts

@@ -0,0 +1,29 @@
+import { MCPPromptMeta } from "./MCPPromptMeta.js";
+import { MCPResourceMeta } from "./MCPResourceMeta.js";
+import { MCPToolMeta } from "./MCPToolMeta.js";
+import { ControllerMetadata, ControllerType, EggPrototypeName, MCPControllerParams, MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/model/MCPControllerMeta.d.ts
+declare class MCPControllerMeta implements ControllerMetadata {
+  readonly protoName: EggPrototypeName;
+  readonly controllerName: string;
+  readonly className: string;
+  readonly methods: never[];
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly type: ControllerType;
+  readonly name?: string;
+  readonly version: string;
+  readonly needAcl: boolean;
+  readonly aclCode?: string;
+  readonly tools: MCPToolMeta[];
+  readonly resources: MCPResourceMeta[];
+  readonly prompts: MCPPromptMeta[];
+  readonly timeout?: number;
+  get id(): string;
+  constructor(className: string, protoName: EggPrototypeName, controllerName: string, version: string, tools: MCPToolMeta[], resources: MCPResourceMeta[], prompts: MCPPromptMeta[], middlewares: MiddlewareFunc[], name?: string, needAcl?: boolean, aclCode?: string, meta?: MCPControllerParams);
+  getMethodMiddlewares(method: MCPPromptMeta | MCPToolMeta | MCPResourceMeta): readonly MiddlewareFunc[];
+  hasMethodAcl(method: MCPPromptMeta | MCPToolMeta | MCPResourceMeta): boolean;
+  getMethodAcl(method: MCPPromptMeta | MCPToolMeta | MCPResourceMeta): string | undefined;
+}
+//#endregion
+export { MCPControllerMeta };

package/dist/model/MCPControllerMeta.js

@@ -0,0 +1,51 @@
+import "./MCPResourceMeta.js";
+import { ControllerType } from "@eggjs/tegg-types";
+
+//#region src/model/MCPControllerMeta.ts
+var MCPControllerMeta = class {
+	protoName;
+	controllerName;
+	className;
+	methods;
+	middlewares;
+	type = ControllerType.MCP;
+	name;
+	version;
+	needAcl;
+	aclCode;
+	tools;
+	resources;
+	prompts;
+	timeout;
+	get id() {
+		return `${this.name ?? this.controllerName}:${this.version}`;
+	}
+	constructor(className, protoName, controllerName, version, tools, resources, prompts, middlewares, name, needAcl, aclCode, meta) {
+		this.protoName = protoName;
+		this.controllerName = controllerName;
+		this.className = className;
+		this.name = name;
+		this.version = version;
+		this.tools = tools;
+		this.resources = resources;
+		this.prompts = prompts;
+		this.middlewares = middlewares;
+		this.methods = [];
+		this.needAcl = !!needAcl;
+		this.aclCode = aclCode;
+		this.timeout = meta?.timeout;
+	}
+	getMethodMiddlewares(method) {
+		if (this.middlewares.length) return [...this.middlewares, ...method.middlewares];
+		return method.middlewares;
+	}
+	hasMethodAcl(method) {
+		return method.needAcl || this.needAcl;
+	}
+	getMethodAcl(method) {
+		return method.aclCode || this.aclCode;
+	}
+};
+
+//#endregion
+export { MCPControllerMeta };

package/dist/model/MCPPromptMeta.d.ts

@@ -0,0 +1,28 @@
+import { PromptArgsSchemaDetail } from "../util/MCPInfoUtil.js";
+import { MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/model/MCPPromptMeta.d.ts
+declare class MCPPromptMeta {
+  readonly name: string;
+  readonly needAcl: boolean;
+  readonly mcpName?: string;
+  readonly aclCode?: string;
+  readonly description?: string;
+  readonly detail?: PromptArgsSchemaDetail;
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly extra?: number;
+  readonly title?: string;
+  constructor(opt: {
+    name: string;
+    middlewares: MiddlewareFunc[];
+    needAcl?: boolean;
+    aclCode?: string;
+    description?: string;
+    mcpName?: string;
+    detail?: PromptArgsSchemaDetail;
+    extra?: number;
+    title?: string;
+  });
+}
+//#endregion
+export { MCPPromptMeta };

package/dist/model/MCPPromptMeta.js

@@ -0,0 +1,26 @@
+//#region src/model/MCPPromptMeta.ts
+var MCPPromptMeta = class {
+	name;
+	needAcl;
+	mcpName;
+	aclCode;
+	description;
+	detail;
+	middlewares;
+	extra;
+	title;
+	constructor(opt) {
+		this.name = opt.name;
+		this.needAcl = !!opt.needAcl;
+		this.description = opt.description;
+		this.mcpName = opt.mcpName;
+		this.middlewares = opt.middlewares;
+		this.aclCode = opt.aclCode;
+		this.detail = opt.detail;
+		this.extra = opt.extra;
+		this.title = opt.title;
+	}
+};
+
+//#endregion
+export { MCPPromptMeta };

package/dist/model/MCPResourceMeta.d.ts

@@ -0,0 +1,28 @@
+import { MiddlewareFunc } from "@eggjs/tegg-types";
+import { ResourceMetadata, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/model/MCPResourceMeta.d.ts
+declare class MCPResourceMeta {
+  readonly name: string;
+  readonly needAcl: boolean;
+  readonly aclCode?: string;
+  readonly mcpName?: string;
+  readonly uri?: string;
+  readonly template?: ResourceTemplate;
+  readonly metadata?: ResourceMetadata;
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly extra?: number;
+  constructor(opt: {
+    name: string;
+    middlewares: MiddlewareFunc[];
+    needAcl?: boolean;
+    aclCode?: string;
+    mcpName?: string;
+    uri?: string;
+    template?: ConstructorParameters<typeof ResourceTemplate>;
+    metadata?: ResourceMetadata;
+    extra?: number;
+  });
+}
+//#endregion
+export { MCPResourceMeta };

package/dist/model/MCPResourceMeta.js

@@ -0,0 +1,28 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/model/MCPResourceMeta.ts
+var MCPResourceMeta = class {
+	name;
+	needAcl;
+	aclCode;
+	mcpName;
+	uri;
+	template;
+	metadata;
+	middlewares;
+	extra;
+	constructor(opt) {
+		this.name = opt.name;
+		this.needAcl = !!opt.needAcl;
+		this.uri = opt.uri;
+		this.metadata = opt.metadata;
+		if (opt.template) this.template = new ResourceTemplate(opt.template[0], opt.template[1]);
+		this.middlewares = opt.middlewares;
+		this.aclCode = opt.aclCode;
+		this.mcpName = opt.mcpName;
+		this.extra = opt.extra;
+	}
+};
+
+//#endregion
+export { MCPResourceMeta };

package/dist/model/MCPToolMeta.d.ts

@@ -0,0 +1,26 @@
+import { ToolArgsSchemaDetail } from "../util/MCPInfoUtil.js";
+import { MiddlewareFunc } from "@eggjs/tegg-types";
+
+//#region src/model/MCPToolMeta.d.ts
+declare class MCPToolMeta {
+  readonly name: string;
+  readonly needAcl: boolean;
+  readonly aclCode?: string;
+  readonly mcpName?: string;
+  readonly description?: string;
+  readonly detail?: ToolArgsSchemaDetail;
+  readonly middlewares: readonly MiddlewareFunc[];
+  readonly extra?: number;
+  constructor(opt: {
+    name: string;
+    middlewares: MiddlewareFunc[];
+    needAcl?: boolean;
+    aclCode?: string;
+    description?: string;
+    mcpName?: string;
+    detail?: ToolArgsSchemaDetail;
+    extra?: number;
+  });
+}
+//#endregion
+export { MCPToolMeta };

package/dist/model/MCPToolMeta.js

@@ -0,0 +1,24 @@
+//#region src/model/MCPToolMeta.ts
+var MCPToolMeta = class {
+	name;
+	needAcl;
+	aclCode;
+	mcpName;
+	description;
+	detail;
+	middlewares;
+	extra;
+	constructor(opt) {
+		this.name = opt.name;
+		this.needAcl = !!opt.needAcl;
+		this.description = opt.description;
+		this.mcpName = opt.mcpName;
+		this.middlewares = opt.middlewares;
+		this.aclCode = opt.aclCode;
+		this.detail = opt.detail;
+		this.extra = opt.extra;
+	}
+};
+
+//#endregion
+export { MCPToolMeta };

package/dist/model/index.d.ts

@@ -0,0 +1,8 @@
+import { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta } from "./HTTPMethodMeta.js";
+import { HTTPControllerMeta } from "./HTTPControllerMeta.js";
+import { Cookies } from "./HTTPCookies.js";
+import { HTTPResponse } from "./HTTPResponse.js";
+import { MCPPromptMeta } from "./MCPPromptMeta.js";
+import { MCPResourceMeta } from "./MCPResourceMeta.js";
+import { MCPToolMeta } from "./MCPToolMeta.js";
+import { MCPControllerMeta } from "./MCPControllerMeta.js";

package/dist/model/index.js

@@ -0,0 +1,10 @@
+import { BodyParamMeta, CookiesParamMeta, HTTPMethodMeta, HeadersParamMeta, ParamMeta, ParamMetaUtil, PathParamMeta, QueriesParamMeta, QueryParamMeta, RequestParamMeta } from "./HTTPMethodMeta.js";
+import { HTTPControllerMeta } from "./HTTPControllerMeta.js";
+import { Cookies } from "./HTTPCookies.js";
+import { HTTPResponse } from "./HTTPResponse.js";
+import { MCPPromptMeta } from "./MCPPromptMeta.js";
+import { MCPResourceMeta } from "./MCPResourceMeta.js";
+import { MCPToolMeta } from "./MCPToolMeta.js";
+import { MCPControllerMeta } from "./MCPControllerMeta.js";
+
+export {  };

package/dist/util/ControllerInfoUtil.d.ts

@@ -0,0 +1,22 @@
+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;
+  static setControllerTimeout(timeout: number, clazz: EggProtoImplClass): void;
+  static getControllerTimeout(clazz: EggProtoImplClass): number | undefined;
+}
+//#endregion
+export { ControllerInfoUtil };

package/dist/util/ControllerInfoUtil.js

@@ -0,0 +1,54 @@
+import { MetadataUtil } from "@eggjs/core-decorator";
+import { CONTROLLER_ACL, CONTROLLER_AOP_MIDDLEWARES, CONTROLLER_HOST, CONTROLLER_MIDDLEWARES, CONTROLLER_NAME, CONTROLLER_TIMEOUT_METADATA, CONTROLLER_TYPE } from "@eggjs/tegg-types";
+
+//#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);
+	}
+	static setControllerTimeout(timeout, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_TIMEOUT_METADATA, timeout, clazz);
+	}
+	static getControllerTimeout(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_TIMEOUT_METADATA, 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 { MetadataUtil } from "@eggjs/core-decorator";
+import { CONTROLLER_META_DATA } from "@eggjs/tegg-types";
+
+//#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 };