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

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 { MetadataUtil } from "@eggjs/core-decorator";
+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 { 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,23 @@
+//#region src/util/HTTPPriorityUtil.d.ts
+declare class HTTPPriorityUtil {
+  static readonly DEFAULT_PRIORITY = 1e5;
+  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 - path to calculate priority
+  * @returns {number} priority
+  */
+  static calcPathPriority(path: string): number;
+}
+//#endregion
+export { HTTPPriorityUtil };

package/dist/util/HTTPPriorityUtil.js

@@ -0,0 +1,39 @@
+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 - path to calculate priority
+	* @returns {number} priority
+	*/
+	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/MCPInfoUtil.d.ts

@@ -0,0 +1,52 @@
+import { EggProtoImplClass, MCPControllerParams, MCPPromptParams, MCPResourceParams, MCPToolParams } from "@eggjs/tegg-types";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/util/MCPInfoUtil.d.ts
+interface ToolArgsSchemaDetail {
+  argsSchema: Parameters<McpServer["tool"]>["2"];
+  index: number;
+}
+interface PromptArgsSchemaDetail {
+  argsSchema: Parameters<McpServer["prompt"]>["2"];
+  index: number;
+}
+declare class MCPInfoUtil {
+  static setMCPName(name: string, clazz: EggProtoImplClass): void;
+  static getMCPName(clazz: EggProtoImplClass): string | undefined;
+  static setMCPVersion(version: string, clazz: EggProtoImplClass): void;
+  static getMCPVersion(clazz: EggProtoImplClass): string | undefined;
+  static setMCPControllerParams(params: MCPControllerParams | undefined, clazz: EggProtoImplClass): void;
+  static getMCPControllerParams(clazz: EggProtoImplClass): MCPControllerParams | undefined;
+  static setMCPResource(clazz: EggProtoImplClass, methodName: string): void;
+  static getMCPResource(clazz: EggProtoImplClass): string[];
+  static setMCPResourceParams(params: MCPResourceParams & {
+    mcpName?: string;
+  }, clazz: EggProtoImplClass, resourceName: string): void;
+  static getMCPResourceParams(clazz: EggProtoImplClass, resourceName: string): (MCPResourceParams & {
+    mcpName?: string;
+  }) | undefined;
+  static setMCPTool(clazz: EggProtoImplClass, methodName: string): void;
+  static getMCPTool(clazz: EggProtoImplClass): string[];
+  static getMCPToolParams(clazz: EggProtoImplClass, resourceName: string): (MCPToolParams & {
+    mcpName?: string;
+  }) | undefined;
+  static setMCPToolParams(params: MCPToolParams & {
+    mcpName?: string;
+  }, clazz: EggProtoImplClass, resourceName: string): void;
+  static setMCPPrompt(clazz: EggProtoImplClass, methodName: string): void;
+  static getMCPPrompt(clazz: EggProtoImplClass): string[];
+  static setMCPPromptParams(params: MCPPromptParams & {
+    mcpName?: string;
+  }, clazz: EggProtoImplClass, resourceName: string): void;
+  static getMCPPromptParams(clazz: EggProtoImplClass, resourceName: string): (MCPPromptParams & {
+    mcpName?: string;
+  }) | undefined;
+  static setMCPToolArgsInArgs(detail: ToolArgsSchemaDetail, clazz: EggProtoImplClass, methodName: string): void;
+  static getMCPToolArgsIndex(clazz: EggProtoImplClass, methodName: string): ToolArgsSchemaDetail | undefined;
+  static setMCPExtra(index: number, clazz: EggProtoImplClass, methodName: string): void;
+  static getMCPExtra(clazz: EggProtoImplClass, methodName: string): number | undefined;
+  static setMCPPromptArgsInArgs(detail: PromptArgsSchemaDetail, clazz: EggProtoImplClass, methodName: string): void;
+  static getMCPPromptArgsIndex(clazz: EggProtoImplClass, methodName: string): PromptArgsSchemaDetail | undefined;
+}
+//#endregion
+export { MCPInfoUtil, PromptArgsSchemaDetail, ToolArgsSchemaDetail };

package/dist/util/MCPInfoUtil.js

@@ -0,0 +1,87 @@
+import { MetadataUtil } from "@eggjs/core-decorator";
+import { CONTROLLER_MCP_CONTROLLER_PARAMS_MAP, CONTROLLER_MCP_EXTRA_INDEX, CONTROLLER_MCP_NAME, CONTROLLER_MCP_PROMPT_ARGS_INDEX, CONTROLLER_MCP_PROMPT_MAP, CONTROLLER_MCP_PROMPT_PARAMS_MAP, CONTROLLER_MCP_RESOURCE_MAP, CONTROLLER_MCP_RESOURCE_PARAMS_MAP, CONTROLLER_MCP_TOOL_ARGS_INDEX, CONTROLLER_MCP_TOOL_MAP, CONTROLLER_MCP_TOOL_PARAMS_MAP, CONTROLLER_MCP_VERSION } from "@eggjs/tegg-types";
+
+//#region src/util/MCPInfoUtil.ts
+var MCPInfoUtil = class {
+	static setMCPName(name, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_MCP_NAME, name, clazz);
+	}
+	static getMCPName(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_NAME, clazz);
+	}
+	static setMCPVersion(version, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_MCP_VERSION, version, clazz);
+	}
+	static getMCPVersion(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_VERSION, clazz);
+	}
+	static setMCPControllerParams(params, clazz) {
+		MetadataUtil.defineMetaData(CONTROLLER_MCP_CONTROLLER_PARAMS_MAP, params, clazz);
+	}
+	static getMCPControllerParams(clazz) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_CONTROLLER_PARAMS_MAP, clazz);
+	}
+	static setMCPResource(clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_RESOURCE_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, true);
+	}
+	static getMCPResource(clazz) {
+		const methodMap = MetadataUtil.getMetaData(CONTROLLER_MCP_RESOURCE_MAP, clazz);
+		if (!methodMap) return [];
+		return Array.from(methodMap.keys());
+	}
+	static setMCPResourceParams(params, clazz, resourceName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_RESOURCE_PARAMS_MAP, clazz, /* @__PURE__ */ new Map()).set(resourceName, params);
+	}
+	static getMCPResourceParams(clazz, resourceName) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_RESOURCE_PARAMS_MAP, clazz)?.get(resourceName);
+	}
+	static setMCPTool(clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_TOOL_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, true);
+	}
+	static getMCPTool(clazz) {
+		const methodMap = MetadataUtil.getMetaData(CONTROLLER_MCP_TOOL_MAP, clazz);
+		if (!methodMap) return [];
+		return Array.from(methodMap.keys());
+	}
+	static getMCPToolParams(clazz, resourceName) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_TOOL_PARAMS_MAP, clazz)?.get(resourceName);
+	}
+	static setMCPToolParams(params, clazz, resourceName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_TOOL_PARAMS_MAP, clazz, /* @__PURE__ */ new Map()).set(resourceName, params);
+	}
+	static setMCPPrompt(clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_PROMPT_MAP, clazz, /* @__PURE__ */ new Map()).set(methodName, true);
+	}
+	static getMCPPrompt(clazz) {
+		const methodMap = MetadataUtil.getMetaData(CONTROLLER_MCP_PROMPT_MAP, clazz);
+		if (!methodMap) return [];
+		return Array.from(methodMap.keys());
+	}
+	static setMCPPromptParams(params, clazz, resourceName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_PROMPT_PARAMS_MAP, clazz, /* @__PURE__ */ new Map()).set(resourceName, params);
+	}
+	static getMCPPromptParams(clazz, resourceName) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_PROMPT_PARAMS_MAP, clazz)?.get(resourceName);
+	}
+	static setMCPToolArgsInArgs(detail, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_TOOL_ARGS_INDEX, clazz, /* @__PURE__ */ new Map()).set(methodName, detail);
+	}
+	static getMCPToolArgsIndex(clazz, methodName) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_TOOL_ARGS_INDEX, clazz)?.get(methodName);
+	}
+	static setMCPExtra(index, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_EXTRA_INDEX, clazz, /* @__PURE__ */ new Map()).set(methodName, index);
+	}
+	static getMCPExtra(clazz, methodName) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_EXTRA_INDEX, clazz)?.get(methodName);
+	}
+	static setMCPPromptArgsInArgs(detail, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(CONTROLLER_MCP_PROMPT_ARGS_INDEX, clazz, /* @__PURE__ */ new Map()).set(methodName, detail);
+	}
+	static getMCPPromptArgsIndex(clazz, methodName) {
+		return MetadataUtil.getMetaData(CONTROLLER_MCP_PROMPT_ARGS_INDEX, clazz)?.get(methodName);
+	}
+};
+
+//#endregion
+export { MCPInfoUtil };

package/dist/util/MethodInfoUtil.d.ts

@@ -0,0 +1,25 @@
+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;
+  static setMethodTimeout(timeout: number, clazz: EggProtoImplClass, methodName: string): void;
+  static getMethodTimeout(clazz: EggProtoImplClass, methodName: string): number | undefined;
+}
+//#endregion
+export { MethodInfoUtil };

package/dist/util/MethodInfoUtil.js

@@ -0,0 +1,68 @@
+import { MetadataUtil } from "@eggjs/core-decorator";
+import { METHOD_ACL, METHOD_AOP_MIDDLEWARES, METHOD_AOP_REGISTER_MAP, METHOD_CONTEXT_INDEX, METHOD_CONTROLLER_HOST, METHOD_CONTROLLER_TYPE_MAP, METHOD_MIDDLEWARES, METHOD_TIMEOUT_METADATA } from "@eggjs/tegg-types";
+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);
+	}
+	static setMethodTimeout(timeout, clazz, methodName) {
+		MetadataUtil.initOwnMapMetaData(METHOD_TIMEOUT_METADATA, clazz, /* @__PURE__ */ new Map()).set(methodName, timeout);
+	}
+	static getMethodTimeout(clazz, methodName) {
+		return MetadataUtil.getMetaData(METHOD_TIMEOUT_METADATA, clazz)?.get(methodName);
+	}
+};
+
+//#endregion
+export { MethodInfoUtil };

package/dist/util/index.d.ts

@@ -0,0 +1,9 @@
+import { MCPInfoUtil, PromptArgsSchemaDetail, ToolArgsSchemaDetail } from "./MCPInfoUtil.js";
+import { ControllerValidator } from "./validator/ControllerValidator.js";
+import { MethodValidator } from "./validator/MethodValidator.js";
+import "./validator/index.js";
+import { ControllerInfoUtil } from "./ControllerInfoUtil.js";
+import { ControllerMetadataUtil } from "./ControllerMetadataUtil.js";
+import { HTTPInfoUtil } from "./HTTPInfoUtil.js";
+import { HTTPPriorityUtil } from "./HTTPPriorityUtil.js";
+import { MethodInfoUtil } from "./MethodInfoUtil.js";

package/dist/util/index.js

@@ -0,0 +1,11 @@
+import { ControllerInfoUtil } from "./ControllerInfoUtil.js";
+import { ControllerValidator } from "./validator/ControllerValidator.js";
+import { MethodInfoUtil } from "./MethodInfoUtil.js";
+import { MethodValidator } from "./validator/MethodValidator.js";
+import "./validator/index.js";
+import { ControllerMetadataUtil } from "./ControllerMetadataUtil.js";
+import { HTTPInfoUtil } from "./HTTPInfoUtil.js";
+import { HTTPPriorityUtil } from "./HTTPPriorityUtil.js";
+import { MCPInfoUtil } from "./MCPInfoUtil.js";
+
+export {  };

package/dist/util/validator/ControllerValidator.d.ts

@@ -0,0 +1,8 @@
+import { EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/util/validator/ControllerValidator.d.ts
+declare class ControllerValidator {
+  static validate(clazz: EggProtoImplClass): void;
+}
+//#endregion
+export { ControllerValidator };

package/dist/util/validator/ControllerValidator.js

@@ -0,0 +1,16 @@
+import { ControllerInfoUtil } from "../ControllerInfoUtil.js";
+import { ClassUtil } from "@eggjs/metadata";
+
+//#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
+export { ControllerValidator };

package/dist/util/validator/MethodValidator.d.ts

@@ -0,0 +1,8 @@
+import { EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/util/validator/MethodValidator.d.ts
+declare class MethodValidator {
+  static validate(clazz: EggProtoImplClass, methodName: string): void;
+}
+//#endregion
+export { MethodValidator };

package/dist/util/validator/MethodValidator.js

@@ -0,0 +1,31 @@
+import { ControllerInfoUtil } from "../ControllerInfoUtil.js";
+import { MethodInfoUtil } from "../MethodInfoUtil.js";
+import { ClassUtil } from "@eggjs/metadata";
+
+//#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
+export { MethodValidator };

package/dist/util/validator/index.d.ts

@@ -0,0 +1,2 @@
+import { ControllerValidator } from "./ControllerValidator.js";
+import { MethodValidator } from "./MethodValidator.js";

package/dist/util/validator/index.js

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

package/package.json

@@ -1,62 +1,59 @@
 {
   "name": "@eggjs/controller-decorator",
-  "version": "4.0.0-beta.8",
+  "version": "4.0.1-beta.0",
   "description": "tegg controller decorator",
   "keywords": [
-    "egg",
-    "typescript",
-    "decorator",
     "controller",
-    "tegg"
-  ],
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
+    "decorator",
+    "egg",
+    "tegg",
+    "typescript"
   ],
-  "author": "killagu <killa123@126.com>",
-  "license": "MIT",
-  "homepage": "https://github.com/eggjs/tegg/tree/next/core/controller-decorator",
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/core/controller-decorator",
   "bugs": {
-    "url": "https://github.com/eggjs/tegg/issues"
+    "url": "https://github.com/eggjs/egg/issues"
   },
+  "license": "MIT",
+  "author": "killagu <killa123@126.com>",
   "repository": {
     "type": "git",
-    "url": "git@github.com:eggjs/tegg.git",
-    "directory": "core/controller-decorator"
+    "url": "git+https://github.com/eggjs/egg.git",
+    "directory": "tegg/core/controller-decorator"
   },
-  "engines": {
-    "node": ">=22.18.0"
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@eggjs/cookies": "beta",
+    "@modelcontextprotocol/sdk": "^1.23.0",
     "is-type-of": "^2.2.0",
     "path-to-regexp": "^1.9.0",
-    "@eggjs/aop-decorator": "4.0.0-beta.8",
-    "@eggjs/tegg-common-util": "4.0.0-beta.8",
-    "@eggjs/tegg-metadata": "4.0.0-beta.8",
-    "@eggjs/core-decorator": "4.0.0-beta.8",
-    "@eggjs/tegg-types": "4.0.0-beta.8"
+    "@eggjs/aop-decorator": "4.0.1-beta.0",
+    "@eggjs/cookies": "4.0.1-beta.0",
+    "@eggjs/core-decorator": "4.0.1-beta.0",
+    "@eggjs/metadata": "4.0.1-beta.0",
+    "@eggjs/tegg-types": "4.0.1-beta.0",
+    "@eggjs/tegg-common-util": "4.0.1-beta.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.5",
-    "egg": "beta",
+    "@types/node": "^24.10.2",
     "typescript": "^5.9.3",
-    "tsdown": "^0.15.6",
-    "unplugin-unused": "^0.5.3"
+    "egg": "4.1.1-beta.0"
   },
-  "publishConfig": {
-    "access": "public"
+  "engines": {
+    "node": ">=22.18.0"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "scripts": {
-    "clean": "rimraf dist",
-    "build": "tsdown",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsgo --noEmit"
   }
 }