koatty_router 2.1.10 → 2.2.0

package/dist/index.js

@@ -54,7 +54,7 @@ var onFinished__default = /*#__PURE__*/_interopDefault(onFinished);
 
 /*!
 * @Author: richen
-* @Date: 2026-03-08 04:45:07
+* @Date: 2026-04-24 08:20:32
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
@@ -789,6 +789,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__default.default(inflate__default.default(ctx.req), opts).catch((err) => {
     koatty_logger.DefaultLogger.Error(err);
@@ -800,8 +803,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) {
     koatty_logger.DefaultLogger.Error(error);
@@ -810,18 +814,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 = fastQuerystring.parse(str);
-    return {
-      body: result
-    };
+    return result;
   } catch (error) {
     koatty_logger.DefaultLogger.Error("[FormParseError]", error);
     return {};
@@ -853,12 +852,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 formidable.IncomingForm({
     encoding: opts.encoding,
     multiples: opts.multiples,
@@ -881,15 +874,12 @@ function parseMultipart(ctx, opts) {
       if (err) {
         cleanup();
         koatty_logger.DefaultLogger.Error("[MultipartParseError]", err);
-        return resolve({
-          body: {},
-          file: {}
-        });
+        return resolve({});
       }
       uploadFiles = files;
       resolve({
-        body: fields,
-        file: files
+        ...fields,
+        [FILE_KEY]: files
       });
     });
   });
@@ -903,8 +893,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) {
     koatty_logger.DefaultLogger.Error(error);
@@ -945,11 +936,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) {
     koatty_logger.DefaultLogger.Error("[WebSocketParseError]", error);
@@ -1169,6 +1163,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",
@@ -1226,7 +1221,7 @@ function payload(options) {
     if (!Object.prototype.hasOwnProperty.call(ctx, "requestFile")) {
       Helper5.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;
       });
     }
@@ -1246,22 +1241,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 (!Helper5.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) {
     koatty_logger.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({});
@@ -1495,27 +1500,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;
-      }
-      koatty_logger.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;
@@ -1589,15 +1573,6 @@ function injectParamMetaData(app, target, options) {
         }
       }
     });
-    const fastPathScenario = detectFastPathScenario(data);
-    if (fastPathScenario) {
-      const fastPathHandler = createFastPathHandler(fastPathScenario, data);
-      if (fastPathHandler) {
-        koatty_logger.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
@@ -1663,104 +1638,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) {
-      koatty_logger.DefaultLogger.Debug(`Detected fast path scenario A: single query param without validation`);
-      return "SINGLE_QUERY_NO_VALIDATION";
-    }
-    if ((fnName === "Post" || fnName === "RequestBody") && param.isDto) {
-      koatty_logger.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) {
-      koatty_logger.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 = koatty_validation.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) {
-        koatty_logger.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 koatty_validation.ClassValidator.valid(clazz, body, true);
-        } else {
-          validatedValue = koatty_validation.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 = koatty_validation.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") {
@@ -1769,53 +1646,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 koatty_validation.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 koatty_validation.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 koatty_validation.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 koatty_validation.convertParamsType(value, "object");
       };
     default:
       return (value) => koatty_validation.convertParamsType(value, type);
@@ -1843,7 +1691,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":
@@ -1906,14 +1769,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:
@@ -1925,21 +1793,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) {
       koatty_logger.DefaultLogger.Error(`extractParamSources: Failed to parse body: ${err.message}`);
     }
   }
   return {
     query: ctx.query || {},
-    body: bodyData,
+    body,
     params: ctx.params || {},
     headers: ctx.headers || {}
   };
@@ -1969,7 +1834,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;
@@ -1977,8 +1842,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 = koatty_validation.convertParamsType(value, opt.type);
       }
       if (compiledValidator) {
         compiledValidator(convertedValue);
@@ -2283,17 +2146,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));
@@ -2346,17 +2219,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);
@@ -2569,7 +2452,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;
@@ -3213,8 +3108,12 @@ var GrpcRouter = class {
           }
           koatty_logger.DefaultLogger.Debug(`[GRPC_ROUTER] \u2705 Register request mapping: ["${path3}" => ${ctlItem.name}.${ctlItem.method}]`);
           impl[handler.name] = (call, callback) => {
-            koatty_logger.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}`;
+            koatty_logger.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) {
@@ -4011,17 +3910,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);
 }