@faapi/faapi 1.2.0 → 1.2.1

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;
@@ -2134,7 +2139,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 +2403,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 +2751,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 +3111,7 @@ function getClientIp(req) {
 }
 
 // src/server/handleWsUpgrade.ts
+import fs10 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
 import path10 from "path";
 
@@ -3204,24 +3211,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 +3568,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 +3601,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 +3743,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 +3801,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) => ({
@@ -3910,7 +3909,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`
     );
@@ -4083,6 +4082,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);