@faapi/faapi 1.2.0 → 1.3.0

package/dist/index.js

@@ -1505,9 +1505,14 @@ function getVitestImportActual() {
   if (typeof vi?.importActual !== "function") return void 0;
   return vi.importActual.bind(vi);
 }
-async function importWithCacheBust(filePath) {
+async function importWithCacheBust(filePath, bustViteCache = false) {
   const importActual = getVitestImportActual();
   if (importActual) {
+    if (bustViteCache) {
+      let url2 = pathToFileURL(filePath).href;
+      url2 += `?t=${Date.now()}`;
+      return await import(url2);
+    }
     return await importActual(filePath);
   }
   let url = pathToFileURL(filePath).href;
@@ -1868,6 +1873,41 @@ function createContext(request, params, config = {}, ip = "") {
       ctxWithSse.__sseResponse = writer.response;
       ctxWithSse.__sseWriter = writer;
       return writer;
+    },
+    /**
+     * 显式包装成功响应(返回 Response,不会被自动包裹再次包装)
+     *
+     * 用 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);
+    },
+    /**
+     * 返回错误响应(对象形式参数,status 和 code 均可省略)
+     *
+     * - status 省略时 HTTP 状态码默认 500
+     * - code 省略时响应 body 里不含 code 字段(默认 fail 函数只放非 undefined 的字段)
+     * - status 和 code 独立无关联
+     *
+     * 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);
     }
   };
   const extend = config?.extendContext;
@@ -2047,6 +2087,12 @@ 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);
+}
 function mergeMeta(response, meta) {
   const hasMeta = meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0;
   if (!hasMeta) return response;
@@ -2111,7 +2157,7 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
       const result = await injectParamsAsync(handler, ctx, body, injectors);
       const sseResponse = pickSseAndAutoClose();
       if (sseResponse) return sseResponse;
-      return toResponse(result, meta);
+      return toResponse(wrapResult(result, ctx), meta);
     } catch (err) {
       autoCloseSseOnError();
       throw err;
@@ -2122,7 +2168,7 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
       const result = await injectParamsAsync(handler, ctx, body, injectors);
       const sseResponse = pickSseAndAutoClose();
       if (sseResponse) return sseResponse;
-      return toResponse(result, meta);
+      return toResponse(wrapResult(result, ctx), meta);
     } catch (err) {
       autoCloseSseOnError();
       throw err;
@@ -2134,7 +2180,7 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
 // src/testServer.ts
 import path12 from "path";
 import os from "os";
-import fs9 from "fs/promises";
+import fs11 from "fs/promises";
 
 // src/router/scanRoutes.ts
 import fg from "fast-glob";
@@ -2398,205 +2444,6 @@ init_generateSchemaFiles();
 
 // src/validator/validateInput.ts
 init_schemaName();
-var moduleCache = /* @__PURE__ */ new Map();
-function invalidateSchemaCache() {
-  moduleCache.clear();
-}
-async function loadSchemaModule(schemaPath) {
-  let mod = moduleCache.get(schemaPath);
-  if (!mod) {
-    mod = await importWithCacheBust(schemaPath);
-    moduleCache.set(schemaPath, mod);
-  }
-  return mod;
-}
-async function validateInput(schemaPath, method, inputType, input) {
-  const schemaName = getSchemaName(method, inputType);
-  const schemaKey = `${schemaName}Schema`;
-  let mod;
-  try {
-    mod = await loadSchemaModule(schemaPath);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new InternalError(`Schema \u6A21\u5757\u52A0\u8F7D\u5931\u8D25: ${schemaPath}: ${reason}`);
-  }
-  const schema = mod[schemaKey];
-  if (schema === void 0 || schema === null) {
-    const data = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
-    return { valid: true, issues: [], data };
-  }
-  if (typeof schema !== "object" || typeof schema.safeParse !== "function") {
-    throw new InternalError(`Schema \u4E0D\u662F\u6709\u6548\u7684 zod schema: ${schemaPath}#${schemaName}`);
-  }
-  const inputObj = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
-  const zodSchema = schema;
-  const result = zodSchema.safeParse(inputObj);
-  if (result.success) {
-    const data = typeof result.data === "object" && result.data !== null && !Array.isArray(result.data) ? result.data : {};
-    return { valid: true, issues: [], data };
-  }
-  const issues = mapZodIssues(result.error);
-  return { valid: false, issues, data: inputObj };
-}
-function mapZodIssues(error) {
-  return error.issues.map((issue) => {
-    const code = mapZodCode(issue.code, issue.message);
-    const path15 = issue.path.map(String).join(".") || "";
-    return {
-      path: path15,
-      code,
-      expected: issue.expected ?? mapExpectedFromMessage(issue.message),
-      received: issue.received ?? mapReceivedFromMessage(issue.message),
-      message: issue.message
-    };
-  });
-}
-function mapZodCode(zodCode, message) {
-  switch (zodCode) {
-    case "invalid_type":
-    case "invalid_union":
-    case "invalid_union_discriminator":
-      return "TYPE_MISMATCH";
-    case "unrecognized_keys":
-      return "INVALID_FORMAT";
-    case "invalid_value":
-    case "invalid_string":
-    case "too_small":
-    case "too_big":
-    case "invalid_intersection_types":
-    case "not_multiple_of":
-      return "INVALID_VALUE";
-    case "custom":
-      return "INVALID_VALUE";
-    default:
-      if (message.includes("Required") || message.includes("required")) {
-        return "MISSING_FIELD";
-      }
-      return "INVALID_VALUE";
-  }
-}
-function mapExpectedFromMessage(message) {
-  const match = message.match(/Expected\s+(\w+)/i);
-  return match ? match[1].toLowerCase() : "unknown";
-}
-function mapReceivedFromMessage(message) {
-  const match = message.match(/received\s+(\w+)/i);
-  return match ? match[1].toLowerCase() : "unknown";
-}
-
-// src/server/createServer.ts
-import {
-  createServer as createHttpServer
-} from "http";
-import { createSecureServer as createHttp2SecureServer } from "http2";
-import { readFileSync } from "fs";
-import { Readable as Readable2 } from "stream";
-import path11 from "path";
-
-// src/router/matchRoute.ts
-function matchRoute(routes, method, path15) {
-  for (const route of routes) {
-    if (route.method !== method) {
-      continue;
-    }
-    if (!route.isDynamic) {
-      if (route.urlPath === path15) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
-    if (params !== null) {
-      return { route, params };
-    }
-  }
-  return null;
-}
-function matchWsRoute(wsRoutes, path15) {
-  for (const route of wsRoutes) {
-    if (!route.isDynamic) {
-      if (route.urlPath === path15) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
-    if (params !== null) {
-      return { route, params };
-    }
-  }
-  return null;
-}
-function matchDynamicPath(pattern, path15, paramNames, isCatchAll) {
-  const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path15.split("/").filter(Boolean);
-  if (isCatchAll) {
-    const nonCatchAllCount = patternSegments.length - 1;
-    if (pathSegments.length <= nonCatchAllCount) {
-      return null;
-    }
-    const params2 = {};
-    for (let i = 0; i < nonCatchAllCount; i++) {
-      const patternSeg = patternSegments[i];
-      const pathSeg = pathSegments[i];
-      if (patternSeg.startsWith(":")) {
-        const paramName = patternSeg.slice(1);
-        params2[paramName] = pathSeg;
-      } else if (patternSeg !== pathSeg) {
-        return null;
-      }
-    }
-    const catchAllValue = pathSegments.slice(nonCatchAllCount).join("/");
-    const catchAllParamName = patternSegments[nonCatchAllCount].slice(4);
-    params2[catchAllParamName] = catchAllValue;
-    if (Object.keys(params2).length !== paramNames.length) {
-      return null;
-    }
-    return params2;
-  }
-  if (patternSegments.length !== pathSegments.length) {
-    return null;
-  }
-  const params = {};
-  for (let i = 0; i < patternSegments.length; i++) {
-    const patternSeg = patternSegments[i];
-    const pathSeg = pathSegments[i];
-    if (patternSeg.startsWith(":")) {
-      const paramName = patternSeg.slice(1);
-      params[paramName] = pathSeg;
-    } else if (patternSeg !== pathSeg) {
-      return null;
-    }
-  }
-  if (Object.keys(params).length !== paramNames.length) {
-    return null;
-  }
-  return params;
-}
-
-// src/loader/resolveExports.ts
-function resolveExport(module, exportName) {
-  if (exportName in module && typeof module[exportName] !== "undefined") {
-    return module[exportName];
-  }
-  const defaultExport = module.default;
-  if (defaultExport !== null && typeof defaultExport === "object") {
-    const value = defaultExport[exportName];
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return void 0;
-}
-
-// src/loader/validateRouteModule.ts
-function validateRouteModule(value, method, filePath) {
-  if (typeof value !== "function") {
-    throw new Error(
-      `Route module "${filePath}" does not export a valid handler for method "${method}". Expected a function, got ${typeof value}.`
-    );
-  }
-}
 
 // src/cli/compileOnDemand.ts
 import path9 from "path";
@@ -2945,32 +2792,232 @@ function getDevDist() {
   return devDistDir;
 }
 
-// src/loader/loadRouteModule.ts
-async function loadRouteModule(filePath, method, rootDir) {
-  let module;
+// src/validator/validateInput.ts
+var moduleCache = /* @__PURE__ */ new Map();
+function invalidateSchemaCache() {
+  moduleCache.clear();
+}
+async function loadSchemaModule(schemaPath) {
+  let mod = moduleCache.get(schemaPath);
+  if (!mod) {
+    mod = await importWithCacheBust(schemaPath, isDevOnDemandEnabled());
+    moduleCache.set(schemaPath, mod);
+  }
+  return mod;
+}
+async function validateInput(schemaPath, method, inputType, input) {
+  const schemaName = getSchemaName(method, inputType);
+  const schemaKey = `${schemaName}Schema`;
+  let mod;
   try {
-    module = await importWithCacheBust(filePath);
+    mod = await loadSchemaModule(schemaPath);
   } catch (err) {
-    if (isDevOnDemandEnabled() && rootDir) {
-      const dist = getDevDist();
-      if (dist) {
-        const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new InternalError(`Schema \u6A21\u5757\u52A0\u8F7D\u5931\u8D25: ${schemaPath}: ${reason}`);
+  }
+  const schema = mod[schemaKey];
+  if (schema === void 0 || schema === null) {
+    const data = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+    return { valid: true, issues: [], data };
+  }
+  if (typeof schema !== "object" || typeof schema.safeParse !== "function") {
+    throw new InternalError(`Schema \u4E0D\u662F\u6709\u6548\u7684 zod schema: ${schemaPath}#${schemaName}`);
+  }
+  const inputObj = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+  const zodSchema = schema;
+  const result = zodSchema.safeParse(inputObj);
+  if (result.success) {
+    const data = typeof result.data === "object" && result.data !== null && !Array.isArray(result.data) ? result.data : {};
+    return { valid: true, issues: [], data };
+  }
+  const issues = mapZodIssues(result.error);
+  return { valid: false, issues, data: inputObj };
+}
+function mapZodIssues(error) {
+  return error.issues.map((issue) => {
+    const code = mapZodCode(issue.code, issue.message);
+    const path15 = issue.path.map(String).join(".") || "";
+    return {
+      path: path15,
+      code,
+      expected: issue.expected ?? mapExpectedFromMessage(issue.message),
+      received: issue.received ?? mapReceivedFromMessage(issue.message),
+      message: issue.message
+    };
+  });
+}
+function mapZodCode(zodCode, message) {
+  switch (zodCode) {
+    case "invalid_type":
+    case "invalid_union":
+    case "invalid_union_discriminator":
+      return "TYPE_MISMATCH";
+    case "unrecognized_keys":
+      return "INVALID_FORMAT";
+    case "invalid_value":
+    case "invalid_string":
+    case "too_small":
+    case "too_big":
+    case "invalid_intersection_types":
+    case "not_multiple_of":
+      return "INVALID_VALUE";
+    case "custom":
+      return "INVALID_VALUE";
+    default:
+      if (message.includes("Required") || message.includes("required")) {
+        return "MISSING_FIELD";
+      }
+      return "INVALID_VALUE";
+  }
+}
+function mapExpectedFromMessage(message) {
+  const match = message.match(/Expected\s+(\w+)/i);
+  return match ? match[1].toLowerCase() : "unknown";
+}
+function mapReceivedFromMessage(message) {
+  const match = message.match(/received\s+(\w+)/i);
+  return match ? match[1].toLowerCase() : "unknown";
+}
+
+// src/server/createServer.ts
+import {
+  createServer as createHttpServer
+} from "http";
+import { createSecureServer as createHttp2SecureServer } from "http2";
+import { readFileSync } from "fs";
+import { Readable as Readable2 } from "stream";
+import path11 from "path";
+
+// src/router/matchRoute.ts
+function matchRoute(routes, method, path15) {
+  for (const route of routes) {
+    if (route.method !== method) {
+      continue;
+    }
+    if (!route.isDynamic) {
+      if (route.urlPath === path15) {
+        return { route, params: {} };
+      }
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+function matchWsRoute(wsRoutes, path15) {
+  for (const route of wsRoutes) {
+    if (!route.isDynamic) {
+      if (route.urlPath === path15) {
+        return { route, params: {} };
+      }
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+function matchDynamicPath(pattern, path15, paramNames, isCatchAll) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = path15.split("/").filter(Boolean);
+  if (isCatchAll) {
+    const nonCatchAllCount = patternSegments.length - 1;
+    if (pathSegments.length <= nonCatchAllCount) {
+      return null;
+    }
+    const params2 = {};
+    for (let i = 0; i < nonCatchAllCount; i++) {
+      const patternSeg = patternSegments[i];
+      const pathSeg = pathSegments[i];
+      if (patternSeg.startsWith(":")) {
+        const paramName = patternSeg.slice(1);
+        params2[paramName] = pathSeg;
+      } else if (patternSeg !== pathSeg) {
+        return null;
+      }
+    }
+    const catchAllValue = pathSegments.slice(nonCatchAllCount).join("/");
+    const catchAllParamName = patternSegments[nonCatchAllCount].slice(4);
+    params2[catchAllParamName] = catchAllValue;
+    if (Object.keys(params2).length !== paramNames.length) {
+      return null;
+    }
+    return params2;
+  }
+  if (patternSegments.length !== pathSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSeg = patternSegments[i];
+    const pathSeg = pathSegments[i];
+    if (patternSeg.startsWith(":")) {
+      const paramName = patternSeg.slice(1);
+      params[paramName] = pathSeg;
+    } else if (patternSeg !== pathSeg) {
+      return null;
+    }
+  }
+  if (Object.keys(params).length !== paramNames.length) {
+    return null;
+  }
+  return params;
+}
+
+// src/loader/loadRouteModule.ts
+import fs9 from "fs";
+
+// src/loader/resolveExports.ts
+function resolveExport(module, exportName) {
+  if (exportName in module && typeof module[exportName] !== "undefined") {
+    return module[exportName];
+  }
+  const defaultExport = module.default;
+  if (defaultExport !== null && typeof defaultExport === "object") {
+    const value = defaultExport[exportName];
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// src/loader/validateRouteModule.ts
+function validateRouteModule(value, method, filePath) {
+  if (typeof value !== "function") {
+    throw new Error(
+      `Route module "${filePath}" does not export a valid handler for method "${method}". Expected a function, got ${typeof value}.`
+    );
+  }
+}
+
+// src/loader/loadRouteModule.ts
+async function loadRouteModule(filePath, method, rootDir) {
+  if (isDevOnDemandEnabled() && rootDir) {
+    const dist = getDevDist();
+    if (dist) {
+      const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+      if (sourcePath && fs9.existsSync(sourcePath)) {
         try {
-          const compiled = await ensureCompiled(sourcePath, rootDir, dist);
-          if (compiled) {
-            module = await importWithCacheBust(filePath);
-            const handler2 = resolveExport(module, method);
-            validateRouteModule(handler2, method, filePath);
-            return { handler: handler2, method };
-          }
+          await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
-          const compileReason = compileErr instanceof Error ? compileErr.message : String(compileErr);
-          throw new Error(`Failed to compile route module "${sourcePath}": ${compileReason}`, {
+          const reason = compileErr instanceof Error ? compileErr.message : String(compileErr);
+          throw new Error(`Failed to compile route module "${sourcePath}": ${reason}`, {
             cause: compileErr
           });
         }
       }
     }
+  }
+  let module;
+  try {
+    module = await importWithCacheBust(filePath, isDevOnDemandEnabled());
+  } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to load route module "${filePath}": ${reason}`, { cause: err });
   }
@@ -3105,6 +3152,7 @@ function getClientIp(req) {
 }
 
 // src/server/handleWsUpgrade.ts
+import fs10 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
 import path10 from "path";
 
@@ -3204,24 +3252,16 @@ function getPathname(req) {
   return idx >= 0 ? url.slice(0, idx) : url;
 }
 async function loadWsHandler(filePath, ctx, rootDir) {
-  let module;
-  try {
-    module = await importWithCacheBust(filePath);
-  } catch (err) {
-    if (isDevOnDemandEnabled() && rootDir) {
-      const dist = getDevDist();
-      if (dist) {
-        const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-        const compiled = await ensureCompiled(sourcePath, rootDir, dist);
-        if (compiled) {
-          module = await importWithCacheBust(filePath);
-        }
+  if (isDevOnDemandEnabled() && rootDir) {
+    const dist = getDevDist();
+    if (dist) {
+      const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+      if (sourcePath && fs10.existsSync(sourcePath)) {
+        await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
-    if (!module) {
-      throw err;
-    }
   }
+  const module = await importWithCacheBust(filePath, isDevOnDemandEnabled());
   const handler = module["WS"];
   if (typeof handler !== "function") {
     throw new Error(`WS export not found in ${filePath}`);
@@ -3569,7 +3609,7 @@ async function createTestServer(options) {
   } = options;
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns);
   const sorted = sortRoutes(routes);
-  const schemaDist = dist ? path12.isAbsolute(dist) ? dist : path12.resolve(rootDir, dist) : await fs9.mkdtemp(path12.join(os.tmpdir(), "faapi-test-schema-"));
+  const schemaDist = dist ? path12.isAbsolute(dist) ? dist : path12.resolve(rootDir, dist) : await fs11.mkdtemp(path12.join(os.tmpdir(), "faapi-test-schema-"));
   await generateSchemaFiles(sorted, rootDir, schemaDist);
   const { server } = createServer({
     routes: sorted,
@@ -3602,7 +3642,7 @@ async function createTestServer(options) {
       await new Promise((resolve) => {
         server.close(() => resolve());
       });
-      await fs9.rm(schemaDist, { recursive: true, force: true }).catch(() => {
+      await fs11.rm(schemaDist, { recursive: true, force: true }).catch(() => {
       });
       invalidateSchemaCache();
     }
@@ -3744,7 +3784,7 @@ async function connectWs(baseUrl, pathname, options = {}) {
 }
 
 // src/cli/createAppCore.ts
-import fs11 from "fs";
+import fs13 from "fs";
 import path14 from "path";
 import { PassThrough } from "stream";
 
@@ -3802,7 +3842,7 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs10 from "fs";
+import fs12 from "fs";
 import path13 from "path";
 async function hydrateRoutes(manifest) {
   const hydrateRoute = (serialized) => ({
@@ -3901,7 +3941,8 @@ var FAAPI_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "helmet",
   "bodyLimit",
   "logger",
-  "http2"
+  "http2",
+  "response"
 ]);
 function isFaapiConfigKey(key) {
   return FAAPI_CONFIG_KEYS.has(key);
@@ -3910,7 +3951,7 @@ async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
   const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs11.existsSync(routesPath)) {
+  if (!fs13.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -4007,41 +4048,40 @@ async function createAppBase(options) {
       } = injectOpts ?? {};
       const queryStr = query ? "?" + new URLSearchParams(Object.entries(query).map(([k, v]) => [k, String(v)])).toString() : "";
       return new Promise((resolve, reject) => {
-        const mockRes = {
-          statusCode: 200,
-          _headers: {},
-          _body: Buffer.alloc(0),
-          setHeader(name, value) {
-            this._headers[name.toLowerCase()] = value;
-          },
-          appendHeader(name, value) {
-            const key = name.toLowerCase();
-            const existing = this._headers[key];
-            this._headers[key] = existing ? `${existing}, ${value}` : value;
-          },
-          writeHead(status, headers) {
-            this.statusCode = status;
-            if (headers) {
-              Object.assign(this._headers, headers);
-            }
-          },
-          end(data) {
-            const buf = Buffer.isBuffer(data) ? data : Buffer.from(data ?? "");
-            this._body = buf;
-            resolve({
-              status: this.statusCode,
-              headers: new Headers(this._headers),
-              body: this.parseBody()
-            });
-          },
-          parseBody() {
-            try {
-              return JSON.parse(this._body.toString());
-            } catch {
-              return this._body.toString();
-            }
+        const chunks = [];
+        const mockRes = new PassThrough();
+        mockRes.statusCode = 200;
+        mockRes._headers = {};
+        mockRes.setHeader = function(name, value) {
+          this._headers[name.toLowerCase()] = value;
+        };
+        mockRes.appendHeader = function(name, value) {
+          const key = name.toLowerCase();
+          const existing = this._headers[key];
+          this._headers[key] = existing ? `${existing}, ${value}` : value;
+        };
+        mockRes.writeHead = function(status, headers) {
+          this.statusCode = status;
+          if (headers) {
+            Object.assign(this._headers, headers);
           }
         };
+        mockRes.on("data", (chunk) => chunks.push(chunk));
+        mockRes.on("error", reject);
+        mockRes.on("finish", () => {
+          const body2 = Buffer.concat(chunks);
+          let parsed;
+          try {
+            parsed = JSON.parse(body2.toString());
+          } catch {
+            parsed = body2.toString();
+          }
+          resolve({
+            status: mockRes.statusCode,
+            headers: new Headers(mockRes._headers),
+            body: parsed
+          });
+        });
         const listeners = server.listeners("request");
         const handler = listeners[listeners.length - 1];
         if (typeof handler !== "function") {
@@ -4083,6 +4123,10 @@ async function createAppBase(options) {
       if (config?.lifecycle?.onClose) {
         await config.lifecycle.onClose({ rootDir, routes: sorted, server });
       }
+      if (!server.listening) {
+        app.server = null;
+        return;
+      }
       return new Promise((resolve) => {
         server.close((err) => {
           if (err) console.error("Error closing server:", err);