@faapi/faapi 3.0.0 → 3.1.0

package/dist/testing.js

@@ -103,6 +103,144 @@ function createSseWriter() {
   return writer;
 }
 
+// src/errors/FaapiError.ts
+var FaapiError = class extends Error {
+  constructor(code, message, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "FaapiError";
+  }
+  code;
+  statusCode;
+};
+
+// src/errors/httpErrors.ts
+function deriveStatusCode(issues) {
+  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
+  return has400 ? 400 : 422;
+}
+var ValidationError = class extends FaapiError {
+  constructor(message, issues) {
+    super("VALIDATION_ERROR", message, deriveStatusCode(issues));
+    this.issues = issues;
+    this.name = "ValidationError";
+  }
+  issues;
+};
+var RouteNotFoundError = class extends FaapiError {
+  constructor(path11) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
+    this.name = "RouteNotFoundError";
+  }
+};
+var MethodNotAllowedError = class extends FaapiError {
+  constructor(method, path11, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
+    this.allowedMethods = allowedMethods;
+    this.name = "MethodNotAllowedError";
+  }
+  allowedMethods;
+};
+var InternalError = class extends FaapiError {
+  constructor(message) {
+    super("INTERNAL_ERROR", message, 500);
+    this.name = "InternalError";
+  }
+};
+var PayloadTooLargeError = class extends FaapiError {
+  constructor(maxSize) {
+    super("PAYLOAD_TOO_LARGE", `Request body exceeds size limit of ${maxSize} bytes`, 413);
+    this.name = "PayloadTooLargeError";
+  }
+};
+
+// src/response/responseFormatter.ts
+function defaultOk(data) {
+  return { data };
+}
+function defaultFail(e) {
+  const error = { message: e.message };
+  if (e.code !== void 0) error.code = e.code;
+  return { error };
+}
+function getResponseConfig(config) {
+  return config?.response;
+}
+function resolveOkFn(config) {
+  return getResponseConfig(config)?.ok ?? defaultOk;
+}
+function resolveFailFn(config) {
+  return getResponseConfig(config)?.fail ?? defaultFail;
+}
+function jsonOk(body, status = 200, extraHeaders) {
+  return jsonRaw(body, status, extraHeaders);
+}
+function jsonRaw(body, status, extraHeaders) {
+  const headers = new Headers({ "Content-Type": "application/json" });
+  if (extraHeaders) {
+    const extra = new Headers(extraHeaders);
+    extra.forEach((value, key) => headers.set(key, value));
+  }
+  return new Response(JSON.stringify(body), { status, headers });
+}
+function wrapOkResult(result, config) {
+  if (result instanceof Response) return result;
+  return resolveOkFn(config)(result);
+}
+function formatFailResponse(options, config) {
+  const failFn = resolveFailFn(config);
+  const body = failFn({
+    status: options.status,
+    code: options.code,
+    message: options.message
+  });
+  return jsonOk(body, options.status ?? 500);
+}
+function formatErrorResponse(error, config) {
+  const failFn = resolveFailFn(config);
+  if (error instanceof ValidationError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    const bodyObj = typeof body2 === "object" && body2 !== null ? body2 : { error: body2 };
+    const errorObj = bodyObj.error ?? bodyObj;
+    if (errorObj) {
+      errorObj.issues = error.issues;
+    }
+    return jsonOk(bodyObj, error.statusCode);
+  }
+  if (error instanceof MethodNotAllowedError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    return jsonOk(body2, error.statusCode, { Allow: error.allowedMethods.join(", ") });
+  }
+  if (error instanceof PayloadTooLargeError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    return jsonOk(body2, error.statusCode);
+  }
+  if (error instanceof FaapiError) {
+    const body2 = failFn({
+      status: error.statusCode,
+      code: error.code,
+      message: error.message
+    });
+    return jsonOk(body2, error.statusCode);
+  }
+  const message = error instanceof Error ? error.message : "An unknown error occurred";
+  const body = failFn({ status: 500, code: "INTERNAL_ERROR", message });
+  return jsonOk(body, 500);
+}
+
 // src/runtime/createContext.ts
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
@@ -163,11 +301,7 @@ function createContext(request, params, config = {}, ip = "") {
       });
     },
     json(data, status) {
-      const headers = { "Content-Type": "application/json" };
-      return new Response(JSON.stringify(data), {
-        status: status ?? 200,
-        headers
-      });
+      return jsonOk(data, status ?? 200);
     },
     html(html, status) {
       const headers = { "Content-Type": "text/html; charset=utf-8" };
@@ -203,18 +337,22 @@ function createContext(request, params, config = {}, ip = "") {
     /**
      * 显式包装成功响应(返回 Response,不会被自动包裹再次包装)
      *
+     * 实现委托给 [responseFormatter.wrapOkResult](../response/responseFormatter.ts),
+     * 与 handler `return data` 走的自动包裹路径共享同一套 ok 函数。
+     *
      * 用 config.response.ok(或默认 (data) => ({ data })) 包裹 data 并返回 JSON Response。
      * handler 也可直接 return data,框架会自动用 ok 包裹,两者等价。
      */
     ok(data) {
-      const responseConfig = config.response;
-      const okFn = responseConfig?.ok ?? ((d) => ({ data: d }));
-      const body = okFn(data);
-      return ctx.json(body);
+      const body = wrapOkResult(data, config);
+      return jsonOk(body, 200);
     },
     /**
      * 返回错误响应(对象形式参数,status 和 code 均可省略)
      *
+     * 实现委托给 [responseFormatter.formatFailResponse](../response/responseFormatter.ts),
+     * 与 formatErrorResponse(handler 抛错兜底)共享同一套 fail 函数,确保错误格式一致。
+     *
      * - status 省略时 HTTP 状态码默认 500
      * - code 省略时响应 body 里不含 code 字段(默认 fail 函数只放非 undefined 的字段)
      * - status 和 code 独立无关联
@@ -222,18 +360,7 @@ function createContext(request, params, config = {}, ip = "") {
      * body 用 config.response.fail(或默认实现)包装。
      */
     fail(options) {
-      const responseConfig = config.response;
-      const failFn = responseConfig?.fail ?? ((e) => {
-        const error = { message: e.message };
-        if (e.code !== void 0) error.code = e.code;
-        return { error };
-      });
-      const body = failFn({
-        status: options.status,
-        code: options.code,
-        message: options.message
-      });
-      return ctx.json(body, options.status ?? 500);
+      return formatFailResponse(options, config);
     }
   };
   const extend = config?.extendContext;
@@ -463,12 +590,21 @@ function queryToObject(params) {
   return result;
 }
 
-// src/injection/agentRegistry.ts
+// src/injection/skillRegistry.ts
 var registry = /* @__PURE__ */ new Map();
-function listAgents() {
+function listSkills() {
   return Array.from(registry.values());
 }
 
+// src/injection/agentRegistry.ts
+var registry2 = /* @__PURE__ */ new Map();
+function listAgents() {
+  const merged = /* @__PURE__ */ new Map();
+  for (const agent of registry2.values()) merged.set(agent.name, agent);
+  for (const skill of listSkills()) merged.set(skill.name, skill);
+  return Array.from(merged.values());
+}
+
 // src/injection/agentHandle.ts
 var currentFactory = null;
 function getAgentHandle(ctx) {
@@ -540,10 +676,7 @@ async function injectParamsAsync(handler, ctx, body, injectors) {
 
 // src/runtime/invokeHandler.ts
 function wrapResult(result, ctx) {
-  if (result instanceof Response) return result;
-  const responseConfig = ctx.config.response;
-  const okFn = responseConfig?.ok ?? ((d) => ({ data: d }));
-  return okFn(result);
+  return wrapOkResult(result, ctx.config);
 }
 function mergeMeta(response, meta) {
   const hasMeta = meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0;
@@ -726,37 +859,42 @@ function setCachedMiddlewares(absPath, bundle) {
   middlewareCache.set(absPath, bundle);
 }
 async function loadMiddlewaresFile(filePath) {
+  let module;
   try {
-    const module = await importWithCacheBust(filePath);
-    const middlewares = module.default ?? module.middlewares ?? [];
-    if (!Array.isArray(middlewares)) {
-      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: [], injectors: {} };
-    }
-    const validMiddlewares = middlewares.filter((m) => {
-      if (typeof m !== "function") {
-        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
-        return false;
-      }
-      return true;
-    });
-    const injectors = module.injectors ?? {};
-    if (typeof injectors !== "object" || injectors === null) {
-      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: validMiddlewares, injectors: {} };
-    }
-    const validInjectors = {};
-    for (const [name, injector] of Object.entries(injectors)) {
-      if (typeof injector !== "function") {
-        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
-        continue;
-      }
-      validInjectors[name] = injector;
-    }
-    return { middlewares: validMiddlewares, injectors: validInjectors };
-  } catch {
+    module = await importWithCacheBust(filePath);
+  } catch (err) {
+    console.error(
+      `[faapi] Failed to load middlewares from ${filePath}:`,
+      err instanceof Error ? err.stack ?? err.message : err
+    );
+    return { middlewares: [], injectors: {} };
+  }
+  const middlewares = module.default ?? module.middlewares ?? [];
+  if (!Array.isArray(middlewares)) {
+    console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
     return { middlewares: [], injectors: {} };
   }
+  const validMiddlewares = middlewares.filter((m) => {
+    if (typeof m !== "function") {
+      console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
+      return false;
+    }
+    return true;
+  });
+  const injectors = module.injectors ?? {};
+  if (typeof injectors !== "object" || injectors === null) {
+    console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+    return { middlewares: validMiddlewares, injectors: {} };
+  }
+  const validInjectors = {};
+  for (const [name, injector] of Object.entries(injectors)) {
+    if (typeof injector !== "function") {
+      console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
+      continue;
+    }
+    validInjectors[name] = injector;
+  }
+  return { middlewares: validMiddlewares, injectors: validInjectors };
 }
 async function loadMergedMiddlewares(middlewarePaths) {
   if (middlewarePaths.length === 0) return void 0;
@@ -2072,52 +2210,6 @@ async function writeSchemaFile(outputPath, source) {
   await fs2.writeFile(outputPath, source, "utf-8");
 }
 
-// src/errors/FaapiError.ts
-var FaapiError = class extends Error {
-  constructor(code, message, statusCode) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "FaapiError";
-  }
-  code;
-  statusCode;
-};
-
-// src/errors/httpErrors.ts
-function deriveStatusCode(issues) {
-  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
-  return has400 ? 400 : 422;
-}
-var ValidationError = class extends FaapiError {
-  constructor(message, issues) {
-    super("VALIDATION_ERROR", message, deriveStatusCode(issues));
-    this.issues = issues;
-    this.name = "ValidationError";
-  }
-  issues;
-};
-var RouteNotFoundError = class extends FaapiError {
-  constructor(path11) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
-    this.name = "RouteNotFoundError";
-  }
-};
-var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path11, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
-    this.allowedMethods = allowedMethods;
-    this.name = "MethodNotAllowedError";
-  }
-  allowedMethods;
-};
-var InternalError = class extends FaapiError {
-  constructor(message) {
-    super("INTERNAL_ERROR", message, 500);
-    this.name = "InternalError";
-  }
-};
-
 // src/cli/compileOnDemand.ts
 import path7 from "path";
 import fs6 from "fs";
@@ -2371,9 +2463,25 @@ function isProductFresh(sourceAbsPath, productAbsPath) {
     return false;
   }
 }
-var compiledFiles = /* @__PURE__ */ new Set();
+function createDevOnDemandState() {
+  return {
+    enabled: false,
+    distDir: void 0,
+    compiledFiles: /* @__PURE__ */ new Set(),
+    generatedSchemas: /* @__PURE__ */ new Set(),
+    inFlightCompilations: /* @__PURE__ */ new Map(),
+    inFlightSchemaGenerations: /* @__PURE__ */ new Map()
+  };
+}
+var state = createDevOnDemandState();
 async function ensureCompiled(sourceAbsPath, rootDir, dist) {
-  if (compiledFiles.has(sourceAbsPath)) {
+  const inFlight = state.inFlightCompilations.get(sourceAbsPath);
+  if (inFlight) {
+    await inFlight.catch(() => {
+    });
+    return false;
+  }
+  if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
   if (!fs6.existsSync(sourceAbsPath)) {
@@ -2381,17 +2489,25 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
   if (productPath && isProductFresh(sourceAbsPath, productPath)) {
-    compiledFiles.add(sourceAbsPath);
+    state.compiledFiles.add(sourceAbsPath);
     return false;
   }
-  await compileDevRoutes({
-    rootDir,
-    dist,
-    files: [sourceAbsPath],
-    logLevel: "silent"
-  });
-  compiledFiles.add(sourceAbsPath);
-  return true;
+  const compilePromise = (async () => {
+    await compileDevRoutes({
+      rootDir,
+      dist,
+      files: [sourceAbsPath],
+      logLevel: "silent"
+    });
+    state.compiledFiles.add(sourceAbsPath);
+  })();
+  state.inFlightCompilations.set(sourceAbsPath, compilePromise);
+  try {
+    await compilePromise;
+    return true;
+  } finally {
+    state.inFlightCompilations.delete(sourceAbsPath);
+  }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
   const rel = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
@@ -2400,9 +2516,14 @@ function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
   return path7.resolve(rootDir, dist, jsRel);
 }
-var generatedSchemas = /* @__PURE__ */ new Set();
 async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
-  if (generatedSchemas.has(schemaPath)) {
+  const inFlight = state.inFlightSchemaGenerations.get(schemaPath);
+  if (inFlight) {
+    await inFlight.catch(() => {
+    });
+    return false;
+  }
+  if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
   const prodAbsPath = path7.resolve(rootDir, routeFilePath);
@@ -2411,7 +2532,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
-    generatedSchemas.add(schemaPath);
+    state.generatedSchemas.add(schemaPath);
     return false;
   }
   const fileRoutes = routes.filter((r) => r.filePath === routeFilePath);
@@ -2420,9 +2541,17 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   }
   const sourceRelPath = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
-  await generateSchemaFiles(sourceRoutes, rootDir, dist);
-  generatedSchemas.add(schemaPath);
-  return true;
+  const generatePromise = (async () => {
+    await generateSchemaFiles(sourceRoutes, rootDir, dist);
+    state.generatedSchemas.add(schemaPath);
+  })();
+  state.inFlightSchemaGenerations.set(schemaPath, generatePromise);
+  try {
+    await generatePromise;
+    return true;
+  } finally {
+    state.inFlightSchemaGenerations.delete(schemaPath);
+  }
 }
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   const rel = path7.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
@@ -2436,13 +2565,11 @@ function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   if (fs6.existsSync(tsAbs)) return tsAbs;
   return path7.resolve(rootDir, srcRel);
 }
-var devOnDemandEnabled = false;
 function isDevOnDemandEnabled() {
-  return devOnDemandEnabled;
+  return state.enabled;
 }
-var devDistDir;
 function getDevDist() {
-  return devDistDir;
+  return state.distDir;
 }
 
 // src/validator/validateInput.ts
@@ -2965,52 +3092,6 @@ import fs8 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
 import path8 from "path";
 
-// src/errors/formatErrorResponse.ts
-function formatErrorResponse(error) {
-  if (error instanceof ValidationError) {
-    const body2 = {
-      code: error.code,
-      message: error.message,
-      issues: error.issues
-    };
-    return new Response(JSON.stringify({ error: body2 }), {
-      status: error.statusCode,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  if (error instanceof MethodNotAllowedError) {
-    const body2 = {
-      code: error.code,
-      message: error.message
-    };
-    return new Response(JSON.stringify({ error: body2 }), {
-      status: error.statusCode,
-      headers: {
-        "Content-Type": "application/json",
-        Allow: error.allowedMethods.join(", ")
-      }
-    });
-  }
-  if (error instanceof FaapiError) {
-    const body2 = {
-      code: error.code,
-      message: error.message
-    };
-    return new Response(JSON.stringify({ error: body2 }), {
-      status: error.statusCode,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  const body = {
-    code: "INTERNAL_ERROR",
-    message: error instanceof Error ? error.message : "An unknown error occurred"
-  };
-  return new Response(JSON.stringify({ error: body }), {
-    status: 500,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-
 // src/server/serverUtils.ts
 function nodeHttpToWebHeaders(req) {
   const headers = new Headers();
@@ -3024,9 +3105,9 @@ function nodeHttpToWebHeaders(req) {
   }
   return headers;
 }
-function buildErrorResponse(err) {
+function buildErrorResponse(err, config) {
   try {
-    return formatErrorResponse(err);
+    return formatErrorResponse(err, config);
   } catch {
     return new Response(
       JSON.stringify({ error: { code: "INTERNAL_ERROR", message: "Internal Server Error" } }),
@@ -3221,25 +3302,51 @@ function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
 }
 function limitStreamSize(stream, maxSize) {
   let totalSize = 0;
-  const reader = stream.getReader();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await reader.read();
-      if (done) {
-        controller.close();
+  let reader;
+  let errored = false;
+  const releaseReader = () => {
+    if (reader) {
+      try {
         reader.releaseLock();
-        return;
+      } catch {
       }
-      totalSize += value.byteLength;
-      if (totalSize > maxSize) {
-        controller.error(new Error(`\u8BF7\u6C42\u4F53\u8D85\u8FC7\u5927\u5C0F\u9650\u5236 ${maxSize} \u5B57\u8282`));
-        reader.releaseLock();
-        return;
+      reader = void 0;
+    }
+  };
+  const failStream = (controller, err) => {
+    if (errored) return;
+    errored = true;
+    controller.error(err instanceof Error ? err : new Error(String(err)));
+    releaseReader();
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      if (!reader) reader = stream.getReader();
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          releaseReader();
+          return;
+        }
+        totalSize += value.byteLength;
+        if (totalSize > maxSize) {
+          failStream(controller, new PayloadTooLargeError(maxSize));
+          return;
+        }
+        controller.enqueue(value);
+      } catch (err) {
+        failStream(controller, err);
       }
-      controller.enqueue(value);
     },
     cancel(reason) {
-      reader.cancel(reason);
+      if (reader) {
+        try {
+          reader.cancel(reason);
+        } catch {
+        }
+        releaseReader();
+      }
     }
   });
 }
@@ -3320,21 +3427,27 @@ function createServer(options) {
   }
   return { server, routesRef };
 }
-async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+function prepareRequest(req, config, bodyLimit) {
   const request = toWebRequest(req, bodyLimit);
   const method = request.method.toUpperCase();
   const urlPath = new URL(request.url).pathname;
   const ctx = createContext(request, {}, config, getClientIp(req));
   const meta = ctx.meta;
-  const routePipeline = async () => {
-    const match = matchRoute(routes, method, urlPath);
-    if (!match) {
-      const allowedMethods = findAllowedMethods(routes, urlPath);
-      if (allowedMethods.length > 0) {
-        throw new MethodNotAllowedError(method, urlPath, allowedMethods);
-      }
-      throw new RouteNotFoundError(urlPath);
-    }
+  return { request, ctx, meta, method, urlPath };
+}
+function resolveRouteOrThrow(routes, method, urlPath) {
+  const match = matchRoute(routes, method, urlPath);
+  if (match) return match;
+  const allowedMethods = findAllowedMethods(routes, urlPath);
+  if (allowedMethods.length > 0) {
+    throw new MethodNotAllowedError(method, urlPath, allowedMethods);
+  }
+  throw new RouteNotFoundError(urlPath);
+}
+function createRoutePipeline(opts) {
+  const { routes, method, urlPath, ctx, request, rootDir, dist, globalInjectors } = opts;
+  return async () => {
+    const match = resolveRouteOrThrow(routes, method, urlPath);
     ctx.params = match.params;
     const { route } = match;
     const absoluteFilePath = path9.resolve(rootDir, route.filePath);
@@ -3364,37 +3477,44 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
       }
     }
     const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
-    const response = await invokeHandler(
-      routeModule.handler,
-      ctx,
-      body,
-      route.middlewares,
-      mergedInjectors
-    );
-    return response;
+    return await invokeHandler(routeModule.handler, ctx, body, route.middlewares, mergedInjectors);
   };
-  try {
-    let response;
-    const outerMiddlewares = [];
-    if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
-    if (globalMiddlewares && globalMiddlewares.length > 0) {
-      outerMiddlewares.push(...globalMiddlewares);
-    }
-    if (outerMiddlewares.length > 0) {
-      response = await compose(outerMiddlewares, ctx, routePipeline);
-    } else {
-      response = await routePipeline();
+}
+async function sendSuccessResponse(response, res) {
+  await sendNodeResponse(response, res);
+}
+async function sendErrorResponse(err, meta, res, onError, ctx) {
+  await sendNodeResponse(mergeMeta(buildErrorResponse(err, ctx.config), meta), res);
+  if (onError) {
+    try {
+      await onError(err, ctx);
+    } catch {
     }
-    await sendNodeResponse(response, res);
+  }
+}
+async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+  const { request, ctx, meta, method, urlPath } = prepareRequest(req, config, bodyLimit);
+  const routePipeline = createRoutePipeline({
+    routes,
+    method,
+    urlPath,
+    ctx,
+    request,
+    rootDir,
+    dist,
+    globalMiddlewares,
+    globalInjectors
+  });
+  const outerMiddlewares = [];
+  if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
+  if (globalMiddlewares && globalMiddlewares.length > 0) {
+    outerMiddlewares.push(...globalMiddlewares);
+  }
+  try {
+    const response = outerMiddlewares.length > 0 ? await compose(outerMiddlewares, ctx, routePipeline) : await routePipeline();
+    await sendSuccessResponse(response, res);
   } catch (err) {
-    const errorResponse = buildErrorResponse(err);
-    await sendNodeResponse(mergeMeta(errorResponse, meta), res);
-    if (onError) {
-      try {
-        await onError(err, ctx);
-      } catch {
-      }
-    }
+    await sendErrorResponse(err, meta, res, onError, ctx);
   }
 }