koatty_router 2.1.9 → 2.2.0

package/dist/index.mjs

@@ -10,7 +10,7 @@ import { buildSchema } from 'koatty_graphql';
 import 'reflect-metadata';
 import { OnEvent, AppEvent, Component, CONTROLLER_ROUTER, KoattyApplication } from 'koatty_core';
 import { Project } from 'ts-morph';
-import { ClassValidator, plainToClass, convertParamsType, PARAM_RULE_KEY, PARAM_CHECK_KEY, PARAM_TYPE_KEY, FunctionValidator, paramterTypes } from 'koatty_validation';
+import { ClassValidator, plainToClass, PARAM_RULE_KEY, PARAM_CHECK_KEY, PARAM_TYPE_KEY, FunctionValidator, convertParamsType, paramterTypes } from 'koatty_validation';
 import compose from 'koa-compose';
 import { LRUCache } from 'lru-cache';
 import getRawBody from 'raw-body';
@@ -24,7 +24,7 @@ import { LoadProto, ListServices } from 'koatty_proto';
 
 /*!
 * @Author: richen
-* @Date: 2026-03-07 15:34:44
+* @Date: 2026-04-24 08:20:32
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
@@ -161,9 +161,6 @@ var RouterMiddlewareManager = class _RouterMiddlewareManager {
   headerCache = new LRUCache({
     max: 100
   });
-  // 缓存清理定时器
-  cacheCleanupTimer;
-  CACHE_CLEANUP_INTERVAL = 5 * 60 * 1e3;
   /**
   * Private constructor to enforce singleton pattern
   */
@@ -174,7 +171,6 @@ var RouterMiddlewareManager = class _RouterMiddlewareManager {
     }
     this._instanceId = Math.random().toString(36).substr(2, 9);
     DefaultLogger.Debug(`RouterMiddlewareManager instance created with ID: ${this._instanceId}`);
-    this.startCacheCleanup();
   }
   /**
   * Get singleton instance
@@ -208,22 +204,6 @@ var RouterMiddlewareManager = class _RouterMiddlewareManager {
     DefaultLogger.Debug("RouterMiddlewareManager singleton instance reset");
   }
   /**
-  * Start cache cleanup timer
-  */
-  startCacheCleanup() {
-    this.cacheCleanupTimer = setInterval(() => {
-      this.performCacheCleanup();
-    }, this.CACHE_CLEANUP_INTERVAL);
-  }
-  /**
-  * Perform periodic cache cleanup
-  */
-  performCacheCleanup() {
-    const beforeSize = this.getCacheSize();
-    const afterSize = this.getCacheSize();
-    DefaultLogger.Debug(`Cache cleanup completed. Size: ${beforeSize} -> ${afterSize}`);
-  }
-  /**
   * Get total cache size
   */
   getCacheSize() {
@@ -233,10 +213,6 @@ var RouterMiddlewareManager = class _RouterMiddlewareManager {
   * Destroy manager and cleanup resources
   */
   destroy() {
-    if (this.cacheCleanupTimer) {
-      clearInterval(this.cacheCleanupTimer);
-      this.cacheCleanupTimer = void 0;
-    }
     this.clearCaches();
     this.middlewares.clear();
     DefaultLogger.Debug(`RouterMiddlewareManager instance ${this._instanceId} destroyed`);
@@ -710,9 +686,9 @@ var RouterMiddlewareManager = class _RouterMiddlewareManager {
   /**
   * Create middleware group
   */
-  createGroup(groupName, middlewareNames) {
+  async createGroup(groupName, middlewareNames) {
     const groupMiddleware = this.compose(middlewareNames);
-    this.register({
+    await this.register({
       name: groupName,
       middleware: groupMiddleware,
       metadata: {
@@ -783,6 +759,9 @@ function RegisterMiddleware(app, config) {
   };
 }
 __name(RegisterMiddleware, "RegisterMiddleware");
+
+// src/payload/interface.ts
+var FILE_KEY = /* @__PURE__ */ Symbol.for("koatty.files");
 function parseText(ctx, opts) {
   return getRawBody(inflate(ctx.req), opts).catch((err) => {
     DefaultLogger.Error(err);
@@ -794,8 +773,9 @@ async function parseJson(ctx, opts) {
   const str = await parseText(ctx, opts);
   if (!str) return {};
   try {
-    return {
-      body: JSON.parse(str)
+    const parsed = JSON.parse(str);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {
+      value: parsed
     };
   } catch (error) {
     DefaultLogger.Error(error);
@@ -804,18 +784,13 @@ async function parseJson(ctx, opts) {
 }
 __name(parseJson, "parseJson");
 async function parseForm(ctx, opts) {
-  if (!ctx.request.headers["content-length"] || !ctx.request.headers["content-type"]?.includes("application/x-www-form-urlencoded")) {
-    return {};
-  }
   const str = await parseText(ctx, opts);
   if (!str || str.trim().length === 0) {
     return {};
   }
   try {
     const result = parse(str);
-    return {
-      body: result
-    };
+    return result;
   } catch (error) {
     DefaultLogger.Error("[FormParseError]", error);
     return {};
@@ -847,12 +822,6 @@ __name(deleteFiles, "deleteFiles");
 
 // src/payload/parser/multipart.ts
 function parseMultipart(ctx, opts) {
-  if (!ctx.request.headers["content-type"]?.includes("multipart/form-data")) {
-    return Promise.resolve({
-      body: {},
-      file: {}
-    });
-  }
   const form = new IncomingForm({
     encoding: opts.encoding,
     multiples: opts.multiples,
@@ -875,15 +844,12 @@ function parseMultipart(ctx, opts) {
       if (err) {
         cleanup();
         DefaultLogger.Error("[MultipartParseError]", err);
-        return resolve({
-          body: {},
-          file: {}
-        });
+        return resolve({});
       }
       uploadFiles = files;
       resolve({
-        body: fields,
-        file: files
+        ...fields,
+        [FILE_KEY]: files
       });
     });
   });
@@ -897,8 +863,9 @@ async function parseXml(ctx, opts) {
   const str = await parseText(ctx, opts);
   if (!str) return {};
   try {
-    return {
-      body: xmlParser.parse(str)
+    const parsed = xmlParser.parse(str);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {
+      value: parsed
     };
   } catch (error) {
     DefaultLogger.Error(error);
@@ -939,11 +906,14 @@ async function parseWebSocket(ctx, opts) {
     const str = await parseText(ctx, opts);
     if (!str) return {};
     try {
-      return {
-        body: JSON.parse(str)
+      const parsed = JSON.parse(str);
+      return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {
+        value: parsed
       };
     } catch {
-      return str;
+      return {
+        value: str
+      };
     }
   } catch (error) {
     DefaultLogger.Error("[WebSocketParseError]", error);
@@ -1163,6 +1133,7 @@ var PayloadCacheManager = class _PayloadCacheManager {
 var cacheManager = PayloadCacheManager.getInstance();
 
 // src/payload/payload.ts
+var bodyCache = /* @__PURE__ */ new WeakMap();
 var supportedMethods = /* @__PURE__ */ new Set([
   "POST",
   "PUT",
@@ -1220,7 +1191,7 @@ function payload(options) {
     if (!Object.prototype.hasOwnProperty.call(ctx, "requestFile")) {
       Helper.define(ctx, "requestFile", async (name) => {
         const body = await bodyParser(ctx, opts);
-        const files = body.file ?? {};
+        const files = body[FILE_KEY] ?? {};
         return name ? files[name] : files;
       });
     }
@@ -1240,22 +1211,32 @@ function queryParser(ctx, _options) {
   return Object.assign({}, query, params);
 }
 __name(queryParser, "queryParser");
-async function bodyParser(ctx, options) {
+function bodyParser(ctx, options) {
+  const cached = bodyCache.get(ctx);
+  if (cached !== void 0) return cached;
+  return parseBodyAndCache(ctx, options);
+}
+__name(bodyParser, "bodyParser");
+async function parseBodyAndCache(ctx, options) {
   try {
-    let body = ctx.getMetaData("_body")[0];
-    if (!Helper.isEmpty(body)) {
-      return body;
-    }
+    const cached = bodyCache.get(ctx);
+    if (cached !== void 0) return cached;
     const opts = cacheManager.getMergedOptions(options);
-    body = await parseBody(ctx, opts);
-    ctx.setMetaData("_body", body);
+    const body = await parseBody(ctx, opts);
+    bodyCache.set(ctx, body);
+    try {
+      ctx.setMetaData("_body", body);
+    } catch {
+    }
     return body;
   } catch (err) {
     DefaultLogger.Error(err);
-    return {};
+    const empty = {};
+    bodyCache.set(ctx, empty);
+    return empty;
   }
 }
-__name(bodyParser, "bodyParser");
+__name(parseBodyAndCache, "parseBodyAndCache");
 function parseBody(ctx, options) {
   if (!isSupportedMethod(ctx.method)) {
     return Promise.resolve({});
@@ -1273,6 +1254,8 @@ function parseBody(ctx, options) {
   return parser ? parser(ctx, options) : Promise.resolve({});
 }
 __name(parseBody, "parseBody");
+var cachedProject = null;
+var publicMethodsCache = /* @__PURE__ */ new Map();
 var ParamSourceType = /* @__PURE__ */ (function(ParamSourceType2) {
   ParamSourceType2["QUERY"] = "query";
   ParamSourceType2["BODY"] = "body";
@@ -1487,27 +1470,6 @@ function injectParamMetaData(app, target, options) {
       if (!v.sourceType) {
         v.sourceType = "custom";
       }
-      switch (v.sourceType) {
-        case "query":
-          v.extractorType = "query";
-          break;
-        case "body":
-          v.extractorType = "body";
-          break;
-        case "header":
-          v.extractorType = "header";
-          break;
-        case "path":
-          v.extractorType = "path";
-          break;
-        case "file":
-          v.extractorType = "file";
-          break;
-        case "custom":
-          v.extractorType = "custom";
-          break;
-      }
-      DefaultLogger.Debug(`Set extractorType ${v.extractorType} for param ${v.name}`);
       const validEntry = validData.find((it) => v.index === it.index && it.name === v.name);
       if (validEntry) {
         v.validRule = validEntry.rule;
@@ -1581,15 +1543,6 @@ function injectParamMetaData(app, target, options) {
         }
       }
     });
-    const fastPathScenario = detectFastPathScenario(data);
-    if (fastPathScenario) {
-      const fastPathHandler = createFastPathHandler(fastPathScenario, data);
-      if (fastPathHandler) {
-        DefaultLogger.Debug(`Created fast path handler for ${target.constructor.name}.${meta}, scenario: ${fastPathScenario}`);
-        data.fastPathHandler = fastPathHandler;
-        data.fastPathScenario = fastPathScenario;
-      }
-    }
     const hasAsyncParams = data.some(
       (p) => p.sourceType === "body" || p.sourceType === "file" || p.isDto
       // DTO validation might be async
@@ -1628,8 +1581,15 @@ var injectParam = /* @__PURE__ */ __name((fn, name, sourceType, paramName, defau
   };
 }, "injectParam");
 function getPublicMethods(classFilePath, className) {
-  const project = new Project();
-  const sourceFile = project.addSourceFileAtPath(classFilePath);
+  const cacheKey = `${classFilePath}::${className}`;
+  const cached = publicMethodsCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  if (!cachedProject) {
+    cachedProject = new Project();
+  }
+  const sourceFile = cachedProject.addSourceFileAtPath(classFilePath);
   const classDeclaration = sourceFile.getClass(className);
   const publicMethods = [];
   if (classDeclaration) {
@@ -1640,6 +1600,7 @@ function getPublicMethods(classFilePath, className) {
       }
     }
   }
+  publicMethodsCache.set(cacheKey, publicMethods);
   return publicMethods;
 }
 __name(getPublicMethods, "getPublicMethods");
@@ -1647,104 +1608,6 @@ function getControllerPath(className) {
   return process.env.APP_PATH + "/controller/" + className + ".ts";
 }
 __name(getControllerPath, "getControllerPath");
-function detectFastPathScenario(params) {
-  if (!params || params.length === 0) {
-    return null;
-  }
-  if (params.length === 1) {
-    const param = params[0];
-    const fnName = param.fn?.name || "";
-    if (fnName === "Get" && !param.validRule && !param.isDto) {
-      DefaultLogger.Debug(`Detected fast path scenario A: single query param without validation`);
-      return "SINGLE_QUERY_NO_VALIDATION";
-    }
-    if ((fnName === "Post" || fnName === "RequestBody") && param.isDto) {
-      DefaultLogger.Debug(`Detected fast path scenario B: single DTO from body`);
-      return "SINGLE_DTO_FROM_BODY";
-    }
-  }
-  if (params.length > 1) {
-    const allQueryNoValidation = params.every((param) => {
-      const fnName = param.fn?.name || "";
-      return fnName === "Get" && !param.validRule && !param.isDto;
-    });
-    if (allQueryNoValidation) {
-      DefaultLogger.Debug(`Detected fast path scenario C: multiple query params without validation`);
-      return "MULTIPLE_QUERY_NO_VALIDATION";
-    }
-  }
-  return null;
-}
-__name(detectFastPathScenario, "detectFastPathScenario");
-function createFastPathHandler(scenario, params) {
-  switch (scenario) {
-    case "SINGLE_QUERY_NO_VALIDATION": {
-      const param = params[0];
-      const paramName = param.name;
-      const paramType = param.type;
-      if (paramName) {
-        return (ctx) => {
-          const value = ctx.query?.[paramName];
-          const converted = convertParamsType(value, paramType);
-          return [
-            converted
-          ];
-        };
-      } else {
-        return (ctx) => {
-          const query = ctx.query || {};
-          return [
-            query
-          ];
-        };
-      }
-    }
-    case "SINGLE_DTO_FROM_BODY": {
-      const param = params[0];
-      const clazz = param.clazz;
-      const dtoCheck = param.dtoCheck;
-      if (!clazz) {
-        DefaultLogger.Debug(`Cannot create fast path: DTO class not found`);
-        return null;
-      }
-      return async (ctx) => {
-        const body = await bodyParser(ctx, param.options);
-        let validatedValue;
-        if (dtoCheck) {
-          validatedValue = await ClassValidator.valid(clazz, body, true);
-        } else {
-          validatedValue = plainToClass(clazz, body, true);
-        }
-        return [
-          validatedValue
-        ];
-      };
-    }
-    case "MULTIPLE_QUERY_NO_VALIDATION": {
-      const paramConfigs = params.map((p) => ({
-        name: p.name,
-        type: p.type
-      }));
-      return (ctx) => {
-        const query = ctx.query || {};
-        const results = [];
-        for (const config of paramConfigs) {
-          if (config.name) {
-            const value = query[config.name];
-            const converted = convertParamsType(value, config.type);
-            results.push(converted);
-          } else {
-            results.push(query);
-          }
-        }
-        return results;
-      };
-    }
-    default:
-      return null;
-  }
-}
-__name(createFastPathHandler, "createFastPathHandler");
 function compileTypeConverter(type) {
   const normalizedType = type.toLowerCase();
   if (normalizedType === "string") {
@@ -1753,53 +1616,24 @@ function compileTypeConverter(type) {
   switch (normalizedType) {
     case "number":
       return (value) => {
+        if (typeof value === "number") return value;
         if (value === null || value === void 0 || value === "") return value;
-        const num = Number(value);
-        return isNaN(num) ? value : num;
+        return convertParamsType(value, "number");
       };
     case "boolean":
       return (value) => {
-        if (value === null || value === void 0) return value;
         if (typeof value === "boolean") return value;
-        if (typeof value === "string") {
-          const lower = value.toLowerCase();
-          if (lower === "true" || lower === "1") return true;
-          if (lower === "false" || lower === "0") return false;
-        }
-        return Boolean(value);
+        return convertParamsType(value, "boolean");
       };
     case "array":
       return (value) => {
-        if (value === null || value === void 0) return value;
         if (Array.isArray(value)) return value;
-        if (typeof value === "string") {
-          try {
-            const parsed = JSON.parse(value);
-            return Array.isArray(parsed) ? parsed : [
-              value
-            ];
-          } catch {
-            return [
-              value
-            ];
-          }
-        }
-        return [
-          value
-        ];
+        return convertParamsType(value, "array");
       };
     case "object":
       return (value) => {
-        if (value === null || value === void 0) return value;
-        if (typeof value === "object") return value;
-        if (typeof value === "string") {
-          try {
-            return JSON.parse(value);
-          } catch {
-            return value;
-          }
-        }
-        return value;
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) return value;
+        return convertParamsType(value, "object");
       };
     default:
       return (value) => convertParamsType(value, type);
@@ -1827,7 +1661,22 @@ function generatePrecompiledExtractor(param) {
       } else {
         return (ctx) => ctx.params || {};
       }
-    case "body":
+    case "body": {
+      const bodyOpts = param.options;
+      if (paramName !== void 0) {
+        return async (ctx) => {
+          const parsed = await bodyParser(ctx, bodyOpts);
+          return (parsed ?? {})[paramName];
+        };
+      } else {
+        return async (ctx) => {
+          const parsed = await bodyParser(ctx, bodyOpts);
+          if (!parsed) return {};
+          const { [FILE_KEY]: _files, ...bodyOnly } = parsed;
+          return bodyOnly;
+        };
+      }
+    }
     case "file":
       return null;
     case "custom":
@@ -1890,14 +1739,19 @@ function extractValueFromSource(source, param) {
   switch (param.sourceType) {
     case ParamSourceType.QUERY:
       return paramName ? source.query?.[paramName] : source.query;
-    case ParamSourceType.BODY:
-      return paramName ? source.body?.[paramName] : source.body;
+    case ParamSourceType.BODY: {
+      if (paramName) return source.body?.[paramName];
+      const { [FILE_KEY]: _files, ...bodyFields } = source.body || {};
+      return bodyFields;
+    }
     case ParamSourceType.HEADER:
       return paramName ? source.headers?.[paramName] : source.headers;
     case ParamSourceType.PATH:
       return paramName ? source.params?.[paramName] : source.params;
-    case ParamSourceType.FILE:
-      return paramName ? source.body?.file?.[paramName] : source.body?.file;
+    case ParamSourceType.FILE: {
+      const files = source.body?.[FILE_KEY] || {};
+      return paramName ? files[paramName] : files;
+    }
     case ParamSourceType.CUSTOM:
       return null;
     default:
@@ -1909,21 +1763,18 @@ async function extractParamSources(ctx, params) {
   const needsBody = params.some((param) => {
     return param.sourceType === ParamSourceType.BODY || param.sourceType === ParamSourceType.FILE;
   });
-  const bodyData = {};
+  let body = {};
   if (needsBody) {
     try {
       const parsedBody = await bodyParser(ctx, params[0]?.options);
-      bodyData.body = parsedBody;
-      if (typeof parsedBody === "object" && "file" in parsedBody) {
-        bodyData.file = parsedBody.file;
-      }
+      body = parsedBody || {};
     } catch (err) {
       DefaultLogger.Error(`extractParamSources: Failed to parse body: ${err.message}`);
     }
   }
   return {
     query: ctx.query || {},
-    body: bodyData,
+    body,
     params: ctx.params || {},
     headers: ctx.headers || {}
   };
@@ -1953,7 +1804,7 @@ async function validateParam(app, ctx, value, opt, compiledValidator, compiledTy
       }
       return validatedValue;
     } else {
-      const needsConversion = compiledTypeConverter !== null;
+      const needsConversion = compiledTypeConverter != null;
       const needsValidation = !!(compiledValidator || opt.validRule);
       if (!needsConversion && !needsValidation) {
         return value;
@@ -1961,8 +1812,6 @@ async function validateParam(app, ctx, value, opt, compiledValidator, compiledTy
       let convertedValue = value;
       if (compiledTypeConverter) {
         convertedValue = compiledTypeConverter(value);
-      } else if (opt.type && opt.type !== "string") {
-        convertedValue = convertParamsType(value, opt.type);
       }
       if (compiledValidator) {
         compiledValidator(convertedValue);
@@ -2267,17 +2116,27 @@ var StrategyHandlerFactory = class {
         return converted;
       };
     });
+    const allAsyncHaveExtractor = asyncParams.every((p) => !!p.precompiledExtractor || p.fn && typeof p.fn === "function");
     return async (ctx) => {
-      const bodyData = await extractParamSources(ctx, params);
-      const asyncResults = asyncParams.map((p) => {
-        const rawValue = extractValueFromSource(bodyData, p);
-        if (rawValue === null && p.fn) {
-          return p.fn(ctx, p.options);
-        }
+      const bodyData = allAsyncHaveExtractor ? null : await extractParamSources(ctx, params);
+      const asyncResults = asyncParams.map(async (p) => {
+        if (p.precompiledExtractor) {
+          const rawValue2 = await p.precompiledExtractor(ctx);
+          const value = rawValue2 === void 0 && p.defaultValue !== void 0 ? p.defaultValue : rawValue2;
+          const paramOptions2 = p.precompiledOptions || createParamOptions(p, p.index ?? 0);
+          return validateParam(app, ctx, value, paramOptions2, p.compiledValidator, p.compiledTypeConverter);
+        }
+        if (p.fn && typeof p.fn === "function") {
+          const rawValue2 = await Promise.resolve(p.fn(ctx, p.options));
+          const value = rawValue2 === void 0 && p.defaultValue !== void 0 ? p.defaultValue : rawValue2;
+          const paramOptions2 = p.precompiledOptions || createParamOptions(p, p.index ?? 0);
+          return validateParam(app, ctx, value, paramOptions2, p.compiledValidator, p.compiledTypeConverter);
+        }
+        const rawValue = bodyData ? extractValueFromSource(bodyData, p) : void 0;
         if (rawValue === void 0 && p.defaultValue !== void 0) {
           return p.defaultValue;
         }
-        const paramOptions = p.precompiledOptions || createParamOptions(p, 0);
+        const paramOptions = p.precompiledOptions || createParamOptions(p, p.index ?? 0);
         return validateParam(app, ctx, rawValue, paramOptions, p.compiledValidator, p.compiledTypeConverter);
       });
       const syncResults = syncHandlers.map((h) => h(ctx));
@@ -2330,17 +2189,27 @@ var StrategyHandlerFactory = class {
   * Fallback: Generic async path
   */
   static createGenericAsyncHandler(params, app) {
+    const allHaveExtractorOrFn = params.every((p) => !!p.precompiledExtractor || p.fn && typeof p.fn === "function");
     return async (ctx) => {
-      const sources = await extractParamSources(ctx, params);
-      const paramPromises = params.map((v, k) => {
-        let rawValue = extractValueFromSource(sources, v);
-        if (rawValue === null && v.fn) {
-          rawValue = v.fn(ctx, v.options);
-        }
+      const sources = allHaveExtractorOrFn ? null : await extractParamSources(ctx, params);
+      const paramPromises = params.map(async (v, k) => {
+        if (v.precompiledExtractor) {
+          const rawValue2 = await v.precompiledExtractor(ctx);
+          const value = rawValue2 === void 0 && v.defaultValue !== void 0 ? v.defaultValue : rawValue2;
+          const paramOptions2 = v.precompiledOptions || createParamOptions(v, v.index ?? k);
+          return validateParam(app, ctx, value, paramOptions2, v.compiledValidator, v.compiledTypeConverter);
+        }
+        if (v.fn && typeof v.fn === "function") {
+          const rawValue2 = await Promise.resolve(v.fn(ctx, v.options));
+          const value = rawValue2 === void 0 && v.defaultValue !== void 0 ? v.defaultValue : rawValue2;
+          const paramOptions2 = v.precompiledOptions || createParamOptions(v, v.index ?? k);
+          return validateParam(app, ctx, value, paramOptions2, v.compiledValidator, v.compiledTypeConverter);
+        }
+        let rawValue = sources ? extractValueFromSource(sources, v) : void 0;
         if (rawValue === void 0 && v.defaultValue !== void 0) {
-          rawValue = v.defaultValue;
+          return v.defaultValue;
         }
-        const paramOptions = v.precompiledOptions || createParamOptions(v, k);
+        const paramOptions = v.precompiledOptions || createParamOptions(v, v.index ?? k);
         return validateParam(app, ctx, rawValue, paramOptions, v.compiledValidator, v.compiledTypeConverter);
       });
       return Promise.all(paramPromises);
@@ -2463,6 +2332,8 @@ function validateProtocolConfig(protocol, ext = {}, env = process.env.NODE_ENV |
       break;
     case "http":
     case "https":
+    case "http2":
+    case "http3":
       break;
     default:
       result.valid = false;
@@ -2494,7 +2365,7 @@ var GraphQLRouter = class {
       validation.warnings.forEach((warning) => DefaultLogger.Warn(`[GraphQLRouter] ${warning}`));
     }
     let schemaFilePath = extConfig.schemaFile;
-    if (schemaFilePath && !path.isAbsolute(schemaFilePath)) {
+    if (schemaFilePath && !path.isAbsolute(schemaFilePath) && app.rootPath) {
       schemaFilePath = path.resolve(app.rootPath, schemaFilePath);
     }
     this.options = {
@@ -2551,7 +2422,19 @@ var GraphQLRouter = class {
       rootValue: routeHandler,
       validationRules: validationRules.length > 0 ? validationRules : void 0,
       formatError: this.options.ext?.debug ? void 0 : (error) => {
-        return new Error(error.message);
+        const formatted = {
+          message: error.message
+        };
+        if (error.extensions) {
+          formatted.extensions = error.extensions;
+        }
+        if (error.locations) {
+          formatted.locations = error.locations;
+        }
+        if (error.path) {
+          formatted.path = error.path;
+        }
+        return formatted;
       },
       context: /* @__PURE__ */ __name((req) => {
         return req.koattyContext;
@@ -2609,6 +2492,13 @@ var GraphQLRouter = class {
     this.routerMap.set(name, impl);
   }
   /**
+  * Escape string for safe JavaScript embedding
+  * @private
+  */
+  escapeJsString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/</g, "\\x3c").replace(/>/g, "\\x3e").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  }
+  /**
   * Render GraphiQL interface
   * 
   * @private
@@ -2616,6 +2506,7 @@ var GraphQLRouter = class {
   * @returns {string} HTML content for GraphiQL
   */
   renderGraphiQL(endpoint) {
+    const safeEndpoint = this.escapeJsString(endpoint);
     return `<!DOCTYPE html>
 <html>
 <head>
@@ -2643,7 +2534,7 @@ var GraphQLRouter = class {
   ></script>
   <script>
     const fetcher = GraphiQL.createFetcher({
-      url: '${endpoint}',
+      url: '${safeEndpoint}',
     });
     const root = ReactDOM.createRoot(document.getElementById('graphiql'));
     root.render(
@@ -2725,185 +2616,6 @@ var GraphQLRouter = class {
     DefaultLogger.Debug("GraphQL router cleanup completed");
   }
 };
-var GrpcConnectionPool = class GrpcConnectionPool2 {
-  static {
-    __name(this, "GrpcConnectionPool");
-  }
-  pool;
-  maxSize;
-  constructor(maxSize = 10) {
-    this.pool = /* @__PURE__ */ new Map();
-    this.maxSize = maxSize;
-  }
-  /**
-  * Get connection from pool or create new one
-  */
-  get(serviceName, options) {
-    const connections = this.pool.get(serviceName);
-    if (connections && connections.length > 0) {
-      const conn = connections.pop();
-      DefaultLogger.Debug(`Reused connection from pool for service: ${serviceName}`);
-      return conn;
-    }
-    DefaultLogger.Debug(`Creating new connection for service: ${serviceName}`);
-    return this.create(serviceName, options);
-  }
-  /**
-  * Release connection back to pool
-  */
-  release(serviceName, connection) {
-    if (!connection) return;
-    if (!this.pool.has(serviceName)) {
-      this.pool.set(serviceName, []);
-    }
-    const connections = this.pool.get(serviceName);
-    if (connections.length < this.maxSize) {
-      connections.push(connection);
-      DefaultLogger.Debug(`Connection released back to pool for service: ${serviceName}, pool size: ${connections.length}`);
-    } else {
-      if (connection.close && typeof connection.close === "function") {
-        connection.close();
-      }
-      DefaultLogger.Debug(`Pool full for service: ${serviceName}, connection closed`);
-    }
-  }
-  /**
-  * Create new connection
-  * @param serviceName - Name of the gRPC service
-  * @param options - gRPC client options
-  * @returns Connection object (placeholder, actual implementation depends on gRPC client library)
-  */
-  create(serviceName, options) {
-    DefaultLogger.Debug(`Creating connection stub for service: ${serviceName}`);
-    return {
-      serviceName,
-      createdAt: Date.now(),
-      options,
-      // Placeholder methods
-      close: /* @__PURE__ */ __name(() => {
-        DefaultLogger.Debug(`Closing connection for service: ${serviceName}`);
-      }, "close")
-    };
-  }
-  /**
-  * Cleanup all connections in the pool
-  */
-  clear() {
-    let totalConnections = 0;
-    for (const [_serviceName, connections] of this.pool.entries()) {
-      for (const connection of connections) {
-        if (connection && connection.close && typeof connection.close === "function") {
-          connection.close();
-        }
-        totalConnections++;
-      }
-    }
-    this.pool.clear();
-    DefaultLogger.Info(`gRPC connection pool cleared, closed ${totalConnections} connections`);
-  }
-  /**
-  * Get pool statistics
-  */
-  getStats() {
-    const stats = {};
-    for (const [serviceName, connections] of this.pool.entries()) {
-      stats[serviceName] = connections.length;
-    }
-    return stats;
-  }
-};
-var GrpcBatchProcessor = class GrpcBatchProcessor2 {
-  static {
-    __name(this, "GrpcBatchProcessor");
-  }
-  batchSize;
-  batchQueue;
-  batchTimers;
-  constructor(batchSize = 10) {
-    this.batchSize = batchSize;
-    this.batchQueue = /* @__PURE__ */ new Map();
-    this.batchTimers = /* @__PURE__ */ new Map();
-  }
-  /**
-  * Add request to batch
-  */
-  addRequest(serviceName, request) {
-    return new Promise((resolve, reject) => {
-      if (!this.batchQueue.has(serviceName)) {
-        this.batchQueue.set(serviceName, []);
-      }
-      const queue = this.batchQueue.get(serviceName);
-      queue.push({
-        request,
-        resolve,
-        reject
-      });
-      if (queue.length >= this.batchSize) {
-        this.processBatch(serviceName);
-      } else if (!this.batchTimers.has(serviceName)) {
-        this.batchTimers.set(serviceName, setTimeout(() => {
-          this.processBatch(serviceName);
-        }, 100));
-      }
-    });
-  }
-  /**
-  * Process batch of requests
-  */
-  processBatch(serviceName) {
-    const queue = this.batchQueue.get(serviceName);
-    if (!queue || queue.length === 0) return;
-    const timer = this.batchTimers.get(serviceName);
-    if (timer) {
-      clearTimeout(timer);
-      this.batchTimers.delete(serviceName);
-    }
-    DefaultLogger.Debug(`Processing batch for service ${serviceName}, ${queue.length} requests`);
-    queue.forEach((item, index) => {
-      try {
-        item.resolve({
-          success: true,
-          data: item.request,
-          batchIndex: index,
-          batchSize: queue.length
-        });
-      } catch (error) {
-        item.reject(error);
-      }
-    });
-    this.batchQueue.delete(serviceName);
-    DefaultLogger.Debug(`Batch processing completed for service ${serviceName}`);
-  }
-  /**
-  * Flush all pending batches and cleanup
-  */
-  flush() {
-    let totalProcessed = 0;
-    for (const serviceName of this.batchQueue.keys()) {
-      const queueSize = this.batchQueue.get(serviceName)?.length || 0;
-      this.processBatch(serviceName);
-      totalProcessed += queueSize;
-    }
-    for (const timer of this.batchTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.batchTimers.clear();
-    DefaultLogger.Info(`gRPC batch processor flushed, processed ${totalProcessed} pending requests`);
-  }
-  /**
-  * Get batch queue statistics
-  */
-  getStats() {
-    const stats = [];
-    for (const [serviceName, queue] of this.batchQueue.entries()) {
-      stats.push({
-        serviceName,
-        queueSize: queue.length
-      });
-    }
-    return stats;
-  }
-};
 var StreamManager = class StreamManager2 {
   static {
     __name(this, "StreamManager");
@@ -2916,7 +2628,6 @@ var StreamManager = class StreamManager2 {
       maxConcurrentStreams: config.maxConcurrentStreams || 100,
       streamTimeout: config.streamTimeout || 3e5,
       backpressureThreshold: config.backpressureThreshold || 1e3,
-      bufferSize: config.bufferSize || 64 * 1024,
       ...config
     };
   }
@@ -2937,6 +2648,18 @@ var StreamManager = class StreamManager2 {
     return state;
   }
   /**
+  * 移除流
+  */
+  removeStream(id) {
+    this.streams.delete(id);
+  }
+  /**
+  * 获取流状态
+  */
+  getStreamState(id) {
+    return this.streams.get(id);
+  }
+  /**
   * 更新流状态
   */
   updateStream(id, updates) {
@@ -2946,12 +2669,6 @@ var StreamManager = class StreamManager2 {
     }
   }
   /**
-  * 移除流
-  */
-  removeStream(id) {
-    this.streams.delete(id);
-  }
-  /**
   * 检查是否达到背压阈值
   */
   isBackpressureTriggered(id) {
@@ -3001,8 +2718,6 @@ var GrpcRouter = class {
   protocol;
   options;
   router;
-  connectionPool;
-  batchProcessor;
   streamManager;
   constructor(app, options = {
     protocol: "grpc",
@@ -3017,20 +2732,16 @@ var GrpcRouter = class {
       validation.warnings.forEach((warning) => DefaultLogger.Warn(`[GrpcRouter] ${warning}`));
     }
     let protoFilePath = extConfig.protoFile;
-    if (protoFilePath && !path.isAbsolute(protoFilePath)) {
+    if (protoFilePath && !path.isAbsolute(protoFilePath) && app.rootPath) {
       protoFilePath = path.resolve(app.rootPath, protoFilePath);
     }
     this.options = {
       ...options,
       protoFile: protoFilePath,
-      poolSize: extConfig.poolSize || 10,
-      batchSize: extConfig.batchSize || 10,
       streamConfig: extConfig.streamConfig || {}
     };
     this.protocol = options.protocol || "grpc";
     this.router = /* @__PURE__ */ new Map();
-    this.connectionPool = new GrpcConnectionPool(this.options.poolSize);
-    this.batchProcessor = new GrpcBatchProcessor(this.options.batchSize);
     this.streamManager = new StreamManager(this.options.streamConfig);
   }
   /**
@@ -3103,7 +2814,7 @@ var GrpcRouter = class {
   */
   async handleServerStreaming(call, app, ctlItem) {
     const streamId = `server_${Date.now()}_${Math.random()}`;
-    const streamState = this.streamManager.registerStream(streamId, "server_streaming");
+    this.streamManager.registerStream(streamId, "server_streaming");
     try {
       DefaultLogger.Debug(`[GRPC_ROUTER] Handling server streaming call for ${ctlItem.name}.${ctlItem.method}`);
       const timeout = setTimeout(() => {
@@ -3128,9 +2839,10 @@ var GrpcRouter = class {
           return false;
         }
         call.write(data);
-        this.streamManager.updateStream(streamId, {
-          messageCount: streamState.messageCount + 1
-        });
+        const currentState = this.streamManager.getStreamState(streamId);
+        if (currentState) {
+          currentState.messageCount++;
+        }
         return true;
       };
       ctx.endStream = () => {
@@ -3153,7 +2865,7 @@ var GrpcRouter = class {
   */
   handleClientStreaming(call, callback, app, ctlItem) {
     const streamId = `client_${Date.now()}_${Math.random()}`;
-    const streamState = this.streamManager.registerStream(streamId, "client_streaming");
+    this.streamManager.registerStream(streamId, "client_streaming");
     const messages = [];
     try {
       DefaultLogger.Debug(`[GRPC_ROUTER] Handling client streaming call for ${ctlItem.name}.${ctlItem.method}`);
@@ -3164,10 +2876,11 @@ var GrpcRouter = class {
       }, this.options.streamConfig?.streamTimeout || 3e5);
       call.on("data", (data) => {
         messages.push(data);
-        this.streamManager.updateStream(streamId, {
-          messageCount: streamState.messageCount + 1,
-          bufferSize: streamState.bufferSize + JSON.stringify(data).length
-        });
+        const currentState = this.streamManager.getStreamState(streamId);
+        if (currentState) {
+          currentState.messageCount++;
+          currentState.bufferSize += Buffer.isBuffer(data) ? data.length : Buffer.byteLength(JSON.stringify(data));
+        }
         if (this.streamManager.isBackpressureTriggered(streamId)) {
           DefaultLogger.Warn(`[GRPC_ROUTER] Backpressure triggered for client stream ${streamId}`);
           call.pause();
@@ -3215,7 +2928,7 @@ var GrpcRouter = class {
   */
   handleBidirectionalStreaming(call, app, ctlItem) {
     const streamId = `bidi_${Date.now()}_${Math.random()}`;
-    const streamState = this.streamManager.registerStream(streamId, "bidirectional_streaming");
+    this.streamManager.registerStream(streamId, "bidirectional_streaming");
     try {
       DefaultLogger.Debug(`[GRPC_ROUTER] Handling bidirectional streaming call for ${ctlItem.name}.${ctlItem.method}`);
       const timeout = setTimeout(() => {
@@ -3224,10 +2937,11 @@ var GrpcRouter = class {
         this.streamManager.removeStream(streamId);
       }, this.options.streamConfig?.streamTimeout || 3e5);
       call.on("data", async (data) => {
-        this.streamManager.updateStream(streamId, {
-          messageCount: streamState.messageCount + 1,
-          bufferSize: streamState.bufferSize + JSON.stringify(data).length
-        });
+        const currentState = this.streamManager.getStreamState(streamId);
+        if (currentState) {
+          currentState.messageCount++;
+          currentState.bufferSize += Buffer.isBuffer(data) ? data.length : Buffer.byteLength(JSON.stringify(data));
+        }
         if (this.streamManager.isBackpressureTriggered(streamId)) {
           DefaultLogger.Warn(`[GRPC_ROUTER] Backpressure triggered for bidirectional stream ${streamId}`);
           call.pause();
@@ -3364,8 +3078,12 @@ var GrpcRouter = class {
           }
           DefaultLogger.Debug(`[GRPC_ROUTER] \u2705 Register request mapping: ["${path3}" => ${ctlItem.name}.${ctlItem.method}]`);
           impl[handler.name] = (call, callback) => {
-            DefaultLogger.Warn(`[GRPC_ROUTER] \u26A0\uFE0F Placeholder handler called for: ${handler.name} - this should not happen!`);
-            callback(new Error("This handler should not be called - routing should go through middleware"));
+            const methodPath = `${si.name}/${handler.name}`;
+            DefaultLogger.Warn(`[GRPC_ROUTER] Placeholder handler invoked for ${methodPath}. No controller matched this gRPC method.`);
+            callback({
+              code: 12,
+              message: `Method ${methodPath} not implemented. Ensure a controller with @GrpcMethod('${handler.name}') is registered.`
+            });
           };
         }
         if (Object.keys(impl).length > 0) {
@@ -3450,8 +3168,6 @@ var GrpcRouter = class {
   cleanup() {
     DefaultLogger.Info("Starting gRPC router cleanup...");
     this.streamManager.closeAllStreams();
-    this.batchProcessor.flush();
-    this.connectionPool.clear();
     DefaultLogger.Info("gRPC router cleanup completed");
   }
 };
@@ -3486,7 +3202,7 @@ var HttpRouter = class {
   * @returns 
   */
   SetRouter(name, impl) {
-    if (Helper5.isEmpty(impl.path)) return;
+    if (!impl || Helper5.isEmpty(impl.path)) return;
     const method = (impl.method || "").toLowerCase();
     const routeHandler = impl.implementation;
     if ([
@@ -3701,7 +3417,7 @@ var WebsocketRouter = class {
   * @returns 
   */
   SetRouter(name, impl) {
-    if (Helper.isEmpty(impl.path)) return;
+    if (!impl || Helper.isEmpty(impl.path)) return;
     const routeHandler = impl.implementation;
     this.router.get(impl.path, routeHandler);
     this.routerMap.set(name, impl);
@@ -3940,6 +3656,10 @@ var RouterFactory = class _RouterFactory {
   * Create router instance
   */
   create(protocol, app, options) {
+    if (this.hasShutdown) {
+      DefaultLogger.Debug("RouterFactory: Resetting shutdown state for new router creation");
+      this.hasShutdown = false;
+    }
     const normalizedProtocol = protocol.toLowerCase();
     const RouterClass = this.routerRegistry.get(normalizedProtocol);
     if (!RouterClass) {
@@ -4160,17 +3880,28 @@ function Get(name, defaultValue) {
 }
 __name(Get, "Get");
 function Post(name, defaultValue) {
-  return injectParam(async (ctx, opt) => {
-    const data = await bodyParser(ctx, opt);
-    const params = data.body ?? data;
-    return name ? params[name] : params;
-  }, "Post", ParamSourceType.BODY, name, defaultValue);
+  return injectParam(
+    // NOTE: This fn is a fallback path only. At runtime the strategy extractor uses
+    // param.precompiledExtractor (generated by generatePrecompiledExtractor for BODY type)
+    // which bypasses this fn entirely. This fn is invoked only when precompiledExtractor
+    // is unavailable (e.g. startup compilation failure or CUSTOM source type fallback).
+    async (ctx, opt) => {
+      const data = await bodyParser(ctx, opt);
+      if (name) return data[name];
+      const { [FILE_KEY]: _files, ...bodyOnly } = data || {};
+      return bodyOnly;
+    },
+    "Post",
+    ParamSourceType.BODY,
+    name,
+    defaultValue
+  );
 }
 __name(Post, "Post");
 function File(name, defaultValue) {
   return injectParam(async (ctx, opt) => {
     const body = await bodyParser(ctx, opt);
-    const params = body.file ?? {};
+    const params = body[FILE_KEY] ?? {};
     return name ? params[name] : params;
   }, "File", ParamSourceType.FILE, name, defaultValue);
 }