@websublime/vite-plugin-open-api-server 0.24.0-next.6 → 0.24.0-next.7

package/dist/index.js

@@ -1,10 +1,10 @@
 import { createRequire } from 'module';
-import { mountInternalApi, executeSeeds, createOpenApiServer, mountDevToolsRoutes, createWebSocketHub } from '@websublime/vite-plugin-open-api-core';
-export { defineHandlers, defineSeeds } from '@websublime/vite-plugin-open-api-core';
 import pc from 'picocolors';
-import path2, { dirname, join } from 'path';
-import fg from 'fast-glob';
 import { existsSync } from 'fs';
+import path, { dirname, join } from 'path';
+import { executeSeeds, mountInternalApi, createOpenApiServer, mountDevToolsRoutes, createWebSocketHub } from '@websublime/vite-plugin-open-api-core';
+export { defineHandlers, defineSeeds } from '@websublime/vite-plugin-open-api-core';
+import fg from 'fast-glob';
 import { fileURLToPath } from 'url';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
@@ -111,7 +111,7 @@ async function directoryExists(dirPath) {
 // src/handlers.ts
 async function loadHandlers(handlersDir, viteServer, cwd = process.cwd(), logger = console) {
   const handlers = /* @__PURE__ */ new Map();
-  const absoluteDir = path2.resolve(cwd, handlersDir);
+  const absoluteDir = path.resolve(cwd, handlersDir);
   const dirExists = await directoryExists(absoluteDir);
   if (!dirExists) {
     return {
@@ -128,7 +128,7 @@ async function loadHandlers(handlersDir, viteServer, cwd = process.cwd(), logger
     ignore: ["node_modules/**", "dist/**"]
   });
   for (const file of files) {
-    const absolutePath = path2.join(absoluteDir, file);
+    const absolutePath = path.join(absoluteDir, file);
     const fileHandlers = await loadHandlerFile(absolutePath, viteServer, logger);
     for (const [operationId, handler] of Object.entries(fileHandlers)) {
       if (handlers.has(operationId)) {
@@ -175,7 +175,7 @@ async function loadHandlerFile(filePath, viteServer, logger) {
   }
 }
 async function getHandlerFiles(handlersDir, cwd = process.cwd()) {
-  const absoluteDir = path2.resolve(cwd, handlersDir);
+  const absoluteDir = path.resolve(cwd, handlersDir);
   const dirExists = await directoryExists(absoluteDir);
   if (!dirExists) {
     return [];
@@ -189,6 +189,90 @@ async function getHandlerFiles(handlersDir, cwd = process.cwd()) {
   });
   return files;
 }
+async function loadSeeds(seedsDir, viteServer, cwd = process.cwd(), logger = console) {
+  const seeds = /* @__PURE__ */ new Map();
+  const absoluteDir = path.resolve(cwd, seedsDir);
+  const dirExists = await directoryExists(absoluteDir);
+  if (!dirExists) {
+    return {
+      seeds,
+      fileCount: 0,
+      files: []
+    };
+  }
+  const pattern = "**/*.seeds.{ts,js,mjs}";
+  const files = await fg(pattern, {
+    cwd: absoluteDir,
+    absolute: false,
+    onlyFiles: true,
+    ignore: ["node_modules/**", "dist/**"]
+  });
+  for (const file of files) {
+    const absolutePath = path.join(absoluteDir, file);
+    const fileSeeds = await loadSeedFile(absolutePath, viteServer, logger);
+    for (const [schemaName, seedFn] of Object.entries(fileSeeds)) {
+      if (seeds.has(schemaName)) {
+        logger.warn(
+          `[vite-plugin-open-api-server] Duplicate seed for schema "${schemaName}" in ${file}. Using last definition.`
+        );
+      }
+      seeds.set(schemaName, seedFn);
+    }
+  }
+  return {
+    seeds,
+    fileCount: files.length,
+    files
+  };
+}
+async function loadSeedFile(filePath, viteServer, logger) {
+  try {
+    const moduleNode = viteServer.moduleGraph.getModuleById(filePath);
+    if (moduleNode) {
+      viteServer.moduleGraph.invalidateModule(moduleNode);
+    }
+    const module = await viteServer.ssrLoadModule(filePath);
+    const seeds = module.default ?? module.seeds ?? module;
+    if (!seeds || typeof seeds !== "object") {
+      logger.warn(
+        `[vite-plugin-open-api-server] Invalid seed file ${filePath}: expected object export`
+      );
+      return {};
+    }
+    const validSeeds = {};
+    for (const [key, value] of Object.entries(seeds)) {
+      if (typeof value === "function") {
+        validSeeds[key] = value;
+      }
+    }
+    return validSeeds;
+  } catch (error) {
+    logger.error(
+      `[vite-plugin-open-api-server] Failed to load seed file ${filePath}:`,
+      error instanceof Error ? error.message : error
+    );
+    return {};
+  }
+}
+async function getSeedFiles(seedsDir, cwd = process.cwd()) {
+  const absoluteDir = path.resolve(cwd, seedsDir);
+  const dirExists = await directoryExists(absoluteDir);
+  if (!dirExists) {
+    return [];
+  }
+  const pattern = "**/*.seeds.{ts,js,mjs}";
+  const files = await fg(pattern, {
+    cwd: absoluteDir,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["node_modules/**", "dist/**"]
+  });
+  return files;
+}
+
+// src/hot-reload.ts
+var nodeModulesRe = /(^|[\\/])node_modules([\\/]|$)/;
+var distRe = /(^|[\\/])dist([\\/]|$)/;
 async function createFileWatcher(options) {
   const {
     handlersDir,
@@ -202,8 +286,8 @@ async function createFileWatcher(options) {
   const watchers = [];
   const readyPromises = [];
   let isWatching = true;
-  const handlerPattern = "**/*.handlers.{ts,js,mjs}";
-  const seedPattern = "**/*.seeds.{ts,js,mjs}";
+  const handlerRe = /\.handlers\.(ts|js|mjs)$/;
+  const seedRe = /\.seeds\.(ts|js|mjs)$/;
   const safeInvoke = (callback, filePath, context) => {
     Promise.resolve().then(() => callback(filePath)).catch((error) => {
       logger.error(
@@ -212,80 +296,103 @@ async function createFileWatcher(options) {
       );
     });
   };
-  if (handlersDir && onHandlerChange) {
-    const absoluteHandlersDir = path2.resolve(cwd, handlersDir);
-    const handlerWatcher = watch(handlerPattern, {
-      cwd: absoluteHandlersDir,
-      ignoreInitial: true,
-      ignored: ["**/node_modules/**", "**/dist/**"],
-      persistent: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
+  const buildIgnored = (pattern) => {
+    return (filePath, stats) => {
+      if (nodeModulesRe.test(filePath) || distRe.test(filePath)) {
+        return true;
       }
-    });
-    handlerWatcher.on("add", (file) => {
-      const absolutePath = path2.join(absoluteHandlersDir, file);
-      safeInvoke(onHandlerChange, absolutePath, "Handler add");
-    });
-    handlerWatcher.on("change", (file) => {
-      const absolutePath = path2.join(absoluteHandlersDir, file);
-      safeInvoke(onHandlerChange, absolutePath, "Handler change");
-    });
-    handlerWatcher.on("unlink", (file) => {
-      const absolutePath = path2.join(absoluteHandlersDir, file);
-      safeInvoke(onHandlerChange, absolutePath, "Handler unlink");
-    });
-    handlerWatcher.on("error", (error) => {
-      logger.error("[vite-plugin-open-api-server] Handler watcher error:", error);
-    });
-    readyPromises.push(
-      new Promise((resolve) => {
-        handlerWatcher.on("ready", () => resolve());
-      })
-    );
-    watchers.push(handlerWatcher);
-  }
-  if (seedsDir && onSeedChange) {
-    const absoluteSeedsDir = path2.resolve(cwd, seedsDir);
-    const seedWatcher = watch(seedPattern, {
-      cwd: absoluteSeedsDir,
-      ignoreInitial: true,
-      ignored: ["**/node_modules/**", "**/dist/**"],
-      persistent: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
+      if (!stats) {
+        return false;
       }
-    });
-    seedWatcher.on("add", (file) => {
-      const absolutePath = path2.join(absoluteSeedsDir, file);
-      safeInvoke(onSeedChange, absolutePath, "Seed add");
-    });
-    seedWatcher.on("change", (file) => {
-      const absolutePath = path2.join(absoluteSeedsDir, file);
-      safeInvoke(onSeedChange, absolutePath, "Seed change");
-    });
-    seedWatcher.on("unlink", (file) => {
-      const absolutePath = path2.join(absoluteSeedsDir, file);
-      safeInvoke(onSeedChange, absolutePath, "Seed unlink");
-    });
-    seedWatcher.on("error", (error) => {
-      logger.error("[vite-plugin-open-api-server] Seed watcher error:", error);
-    });
-    readyPromises.push(
-      new Promise((resolve) => {
-        seedWatcher.on("ready", () => resolve());
-      })
-    );
-    watchers.push(seedWatcher);
+      if (!stats.isFile()) {
+        return false;
+      }
+      return !pattern.test(filePath);
+    };
+  };
+  try {
+    if (handlersDir && onHandlerChange) {
+      const absoluteHandlersDir = path.resolve(cwd, handlersDir);
+      if (!existsSync(absoluteHandlersDir)) {
+        logger.warn(
+          `[vite-plugin-open-api-server] Handlers directory does not exist, skipping watcher: ${absoluteHandlersDir}`
+        );
+      } else {
+        const handlerWatcher = watch(absoluteHandlersDir, {
+          ignoreInitial: true,
+          ignored: buildIgnored(handlerRe),
+          persistent: true,
+          awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 50
+          }
+        });
+        handlerWatcher.on("add", (file) => {
+          safeInvoke(onHandlerChange, file, "Handler add");
+        });
+        handlerWatcher.on("change", (file) => {
+          safeInvoke(onHandlerChange, file, "Handler change");
+        });
+        handlerWatcher.on("unlink", (file) => {
+          safeInvoke(onHandlerChange, file, "Handler unlink");
+        });
+        handlerWatcher.on("error", (error) => {
+          logger.error("[vite-plugin-open-api-server] Handler watcher error:", error);
+        });
+        readyPromises.push(
+          new Promise((resolve) => {
+            handlerWatcher.on("ready", () => resolve());
+          })
+        );
+        watchers.push(handlerWatcher);
+      }
+    }
+    if (seedsDir && onSeedChange) {
+      const absoluteSeedsDir = path.resolve(cwd, seedsDir);
+      if (!existsSync(absoluteSeedsDir)) {
+        logger.warn(
+          `[vite-plugin-open-api-server] Seeds directory does not exist, skipping watcher: ${absoluteSeedsDir}`
+        );
+      } else {
+        const seedWatcher = watch(absoluteSeedsDir, {
+          ignoreInitial: true,
+          ignored: buildIgnored(seedRe),
+          persistent: true,
+          awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 50
+          }
+        });
+        seedWatcher.on("add", (file) => {
+          safeInvoke(onSeedChange, file, "Seed add");
+        });
+        seedWatcher.on("change", (file) => {
+          safeInvoke(onSeedChange, file, "Seed change");
+        });
+        seedWatcher.on("unlink", (file) => {
+          safeInvoke(onSeedChange, file, "Seed unlink");
+        });
+        seedWatcher.on("error", (error) => {
+          logger.error("[vite-plugin-open-api-server] Seed watcher error:", error);
+        });
+        readyPromises.push(
+          new Promise((resolve) => {
+            seedWatcher.on("ready", () => resolve());
+          })
+        );
+        watchers.push(seedWatcher);
+      }
+    }
+  } catch (error) {
+    await Promise.allSettled(watchers.map((w) => w.close()));
+    throw error;
   }
   const readyPromise = Promise.all(readyPromises).then(() => {
   });
   return {
     async close() {
       isWatching = false;
-      await Promise.all(watchers.map((w) => w.close()));
+      await Promise.allSettled(watchers.map((w) => w.close()));
     },
     get isWatching() {
       return isWatching;
@@ -299,9 +406,12 @@ function debounce(fn, delay) {
   let timeoutId = null;
   let isRunning = false;
   let pendingArgs = null;
+  let cancelled = false;
   const execute = async (...args) => {
-    if (isRunning) {
-      pendingArgs = args;
+    if (cancelled || isRunning) {
+      if (isRunning && !cancelled) {
+        pendingArgs = args;
+      }
       return;
     }
     isRunning = true;
@@ -312,14 +422,15 @@ function debounce(fn, delay) {
       }
     } finally {
       isRunning = false;
-      if (pendingArgs !== null) {
+      if (pendingArgs !== null && !cancelled) {
         const nextArgs = pendingArgs;
         pendingArgs = null;
         setTimeout(() => execute(...nextArgs), 0);
       }
     }
   };
-  return (...args) => {
+  const debouncedFn = (...args) => {
+    if (cancelled) return;
     if (timeoutId !== null) {
       clearTimeout(timeoutId);
     }
@@ -328,6 +439,97 @@ function debounce(fn, delay) {
       execute(...args);
     }, delay);
   };
+  debouncedFn.cancel = () => {
+    cancelled = true;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    pendingArgs = null;
+  };
+  return debouncedFn;
+}
+async function createPerSpecFileWatchers(instances, vite, cwd, options) {
+  const watchers = [];
+  const allDebouncedFns = [];
+  try {
+    for (const instance of instances) {
+      const debouncedHandlerReload = debounce(
+        () => reloadSpecHandlers(instance, vite, cwd, options),
+        100
+      );
+      const debouncedSeedReload = debounce(
+        () => reloadSpecSeeds(instance, vite, cwd, options),
+        100
+      );
+      allDebouncedFns.push(debouncedHandlerReload, debouncedSeedReload);
+      const innerWatcher = await createFileWatcher({
+        handlersDir: instance.config.handlersDir,
+        seedsDir: instance.config.seedsDir,
+        cwd,
+        logger: options.logger,
+        onHandlerChange: debouncedHandlerReload,
+        onSeedChange: debouncedSeedReload
+      });
+      watchers.push({
+        async close() {
+          debouncedHandlerReload.cancel();
+          debouncedSeedReload.cancel();
+          await innerWatcher.close();
+        },
+        get isWatching() {
+          return innerWatcher.isWatching;
+        },
+        get ready() {
+          return innerWatcher.ready;
+        }
+      });
+    }
+  } catch (error) {
+    for (const fn of allDebouncedFns) fn.cancel();
+    await Promise.allSettled(watchers.map((w) => w.close()));
+    throw error;
+  }
+  return watchers;
+}
+async function reloadSpecHandlers(instance, vite, cwd, options) {
+  try {
+    const logger = options.logger ?? console;
+    const handlersResult = await loadHandlers(instance.config.handlersDir, vite, cwd, logger);
+    instance.server.updateHandlers(handlersResult.handlers);
+    printReloadNotification("handlers", handlersResult.handlers.size, options);
+  } catch (error) {
+    printError(`Failed to reload handlers for spec "${instance.id}"`, error, options);
+  }
+}
+async function reloadSpecSeeds(instance, vite, cwd, options) {
+  try {
+    const logger = options.logger ?? console;
+    const seedsResult = await loadSeeds(instance.config.seedsDir, vite, cwd, logger);
+    let broadcastCount = seedsResult.seeds.size;
+    instance.server.store.clearAll();
+    if (seedsResult.seeds.size > 0) {
+      try {
+        await executeSeeds(seedsResult.seeds, instance.server.store, instance.server.document);
+      } catch (execError) {
+        broadcastCount = 0;
+        printError(
+          `Seeds loaded but executeSeeds failed for spec "${instance.id}"; store is now empty`,
+          execError,
+          options
+        );
+      }
+    }
+    instance.server.wsHub.broadcast({
+      type: "seeds:updated",
+      data: { count: broadcastCount }
+    });
+    if (broadcastCount > 0) {
+      printReloadNotification("seeds", broadcastCount, options);
+    }
+  } catch (error) {
+    printError(`Failed to reload seeds for spec "${instance.id}"`, error, options);
+  }
 }
 
 // src/multi-proxy.ts
@@ -380,7 +582,7 @@ function configureMultiProxy(vite, instances, port) {
 
 // package.json
 var package_default = {
-  version: "0.24.0-next.5"};
+  version: "0.24.0-next.6"};
 
 // src/types.ts
 var ValidationError = class extends Error {
@@ -568,86 +770,6 @@ function validateNoPrefixOverlaps(paths) {
     }
   }
 }
-async function loadSeeds(seedsDir, viteServer, cwd = process.cwd(), logger = console) {
-  const seeds = /* @__PURE__ */ new Map();
-  const absoluteDir = path2.resolve(cwd, seedsDir);
-  const dirExists = await directoryExists(absoluteDir);
-  if (!dirExists) {
-    return {
-      seeds,
-      fileCount: 0,
-      files: []
-    };
-  }
-  const pattern = "**/*.seeds.{ts,js,mjs}";
-  const files = await fg(pattern, {
-    cwd: absoluteDir,
-    absolute: false,
-    onlyFiles: true,
-    ignore: ["node_modules/**", "dist/**"]
-  });
-  for (const file of files) {
-    const absolutePath = path2.join(absoluteDir, file);
-    const fileSeeds = await loadSeedFile(absolutePath, viteServer, logger);
-    for (const [schemaName, seedFn] of Object.entries(fileSeeds)) {
-      if (seeds.has(schemaName)) {
-        logger.warn(
-          `[vite-plugin-open-api-server] Duplicate seed for schema "${schemaName}" in ${file}. Using last definition.`
-        );
-      }
-      seeds.set(schemaName, seedFn);
-    }
-  }
-  return {
-    seeds,
-    fileCount: files.length,
-    files
-  };
-}
-async function loadSeedFile(filePath, viteServer, logger) {
-  try {
-    const moduleNode = viteServer.moduleGraph.getModuleById(filePath);
-    if (moduleNode) {
-      viteServer.moduleGraph.invalidateModule(moduleNode);
-    }
-    const module = await viteServer.ssrLoadModule(filePath);
-    const seeds = module.default ?? module.seeds ?? module;
-    if (!seeds || typeof seeds !== "object") {
-      logger.warn(
-        `[vite-plugin-open-api-server] Invalid seed file ${filePath}: expected object export`
-      );
-      return {};
-    }
-    const validSeeds = {};
-    for (const [key, value] of Object.entries(seeds)) {
-      if (typeof value === "function") {
-        validSeeds[key] = value;
-      }
-    }
-    return validSeeds;
-  } catch (error) {
-    logger.error(
-      `[vite-plugin-open-api-server] Failed to load seed file ${filePath}:`,
-      error instanceof Error ? error.message : error
-    );
-    return {};
-  }
-}
-async function getSeedFiles(seedsDir, cwd = process.cwd()) {
-  const absoluteDir = path2.resolve(cwd, seedsDir);
-  const dirExists = await directoryExists(absoluteDir);
-  if (!dirExists) {
-    return [];
-  }
-  const pattern = "**/*.seeds.{ts,js,mjs}";
-  const files = await fg(pattern, {
-    cwd: absoluteDir,
-    absolute: true,
-    onlyFiles: true,
-    ignore: ["node_modules/**", "dist/**"]
-  });
-  return files;
-}
 
 // src/spec-id.ts
 function slugify(input) {
@@ -1102,7 +1224,12 @@ try {
         orchestrator = await createOrchestrator(resolvedOptions, viteServer, cwd);
         await orchestrator.start();
         configureMultiProxy(viteServer, orchestrator.instances, orchestrator.port);
-        fileWatchers = await setupPerSpecFileWatching(orchestrator, viteServer, cwd);
+        fileWatchers = await createPerSpecFileWatchers(
+          orchestrator.instances,
+          viteServer,
+          cwd,
+          resolvedOptions
+        );
         if (!resolvedOptions.silent && orchestrator.instances.length > 0) {
           const firstInstance = orchestrator.instances[0];
           const bannerInfo = extractBannerInfo(
@@ -1171,66 +1298,6 @@ try {
       orchestrator = null;
     }
   }
-  async function setupPerSpecFileWatching(orch, viteServer, projectCwd) {
-    const watchers = [];
-    try {
-      for (const instance of orch.instances) {
-        const specServer = instance.server;
-        const specConfig = instance.config;
-        const debouncedHandlerReload = debounce(
-          () => reloadSpecHandlers(specServer, specConfig.handlersDir, viteServer, projectCwd),
-          100
-        );
-        const debouncedSeedReload = debounce(
-          () => reloadSpecSeeds(specServer, specConfig.seedsDir, viteServer, projectCwd),
-          100
-        );
-        const watcher = await createFileWatcher({
-          handlersDir: specConfig.handlersDir,
-          seedsDir: specConfig.seedsDir,
-          cwd: projectCwd,
-          onHandlerChange: debouncedHandlerReload,
-          onSeedChange: debouncedSeedReload
-        });
-        watchers.push(watcher);
-      }
-    } catch (error) {
-      await Promise.allSettled(watchers.map((w) => w.close()));
-      throw error;
-    }
-    return watchers;
-  }
-  async function reloadSpecHandlers(server, handlersDir, viteServer, projectCwd) {
-    try {
-      const logger = resolvedOptions.logger ?? console;
-      const handlersResult = await loadHandlers(handlersDir, viteServer, projectCwd, logger);
-      server.updateHandlers(handlersResult.handlers);
-      server.wsHub.broadcast({
-        type: "handlers:updated",
-        data: { count: handlersResult.handlers.size }
-      });
-      printReloadNotification("handlers", handlersResult.handlers.size, resolvedOptions);
-    } catch (error) {
-      printError("Failed to reload handlers", error, resolvedOptions);
-    }
-  }
-  async function reloadSpecSeeds(server, seedsDir, viteServer, projectCwd) {
-    try {
-      const logger = resolvedOptions.logger ?? console;
-      const seedsResult = await loadSeeds(seedsDir, viteServer, projectCwd, logger);
-      server.store.clearAll();
-      if (seedsResult.seeds.size > 0) {
-        await executeSeeds(seedsResult.seeds, server.store, server.document);
-      }
-      server.wsHub.broadcast({
-        type: "seeds:updated",
-        data: { count: seedsResult.seeds.size }
-      });
-      printReloadNotification("seeds", seedsResult.seeds.size, resolvedOptions);
-    } catch (error) {
-      printError("Failed to reload seeds", error, resolvedOptions);
-    }
-  }
 }
 
 // src/devtools.ts
@@ -1269,6 +1336,6 @@ function getDevToolsUrl(port = 4e3, host, protocol) {
   return `${actualProtocol}://${actualHost}:${port}/_devtools/`;
 }
 
-export { API_PROXY_PATH, DEVTOOLS_PROXY_PATH, SPEC_COLORS, ValidationError, WS_PROXY_PATH, configureMultiProxy, createFileWatcher, createOrchestrator, debounce, deriveProxyPath, deriveSpecId, getDevToolsUrl, getHandlerFiles, getSeedFiles, loadHandlers, loadSeeds, normalizeProxyPath, openApiServer, registerDevTools, resolveOptions, slugify, validateSpecs, validateUniqueIds, validateUniqueProxyPaths };
+export { API_PROXY_PATH, DEVTOOLS_PROXY_PATH, SPEC_COLORS, ValidationError, WS_PROXY_PATH, configureMultiProxy, createFileWatcher, createOrchestrator, createPerSpecFileWatchers, debounce, deriveProxyPath, deriveSpecId, getDevToolsUrl, getHandlerFiles, getSeedFiles, loadHandlers, loadSeeds, normalizeProxyPath, openApiServer, registerDevTools, reloadSpecHandlers, reloadSpecSeeds, resolveOptions, slugify, validateSpecs, validateUniqueIds, validateUniqueProxyPaths };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map