@websublime/vite-plugin-open-api-server 0.19.2

package/dist/index.js

@@ -0,0 +1,585 @@
+import { createOpenApiServer, executeSeeds } from '@websublime/vite-plugin-open-api-core';
+export { defineHandlers, defineSeeds } from '@websublime/vite-plugin-open-api-core';
+import pc from 'picocolors';
+import path2 from 'path';
+import fg from 'fast-glob';
+
+// src/plugin.ts
+function printBanner(info, options) {
+  if (options.silent) {
+    return;
+  }
+  const logger = options.logger ?? console;
+  const log = (msg) => logger.info(msg);
+  const BOX = {
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F",
+    horizontal: "\u2500",
+    vertical: "\u2502"
+  };
+  const width = 56;
+  const horizontalLine = BOX.horizontal.repeat(width - 2);
+  log("");
+  log(pc.cyan(`${BOX.topLeft}${horizontalLine}${BOX.topRight}`));
+  log(
+    pc.cyan(BOX.vertical) + centerText("\u{1F680} OpenAPI Mock Server", width - 2) + pc.cyan(BOX.vertical)
+  );
+  log(pc.cyan(`${BOX.bottomLeft}${horizontalLine}${BOX.bottomRight}`));
+  log("");
+  log(
+    `  ${pc.bold(pc.white("API:"))}        ${pc.green(info.title)} ${pc.dim(`v${info.version}`)}`
+  );
+  log(`  ${pc.bold(pc.white("Server:"))}     ${pc.cyan(`http://localhost:${info.port}`)}`);
+  log(
+    `  ${pc.bold(pc.white("Proxy:"))}      ${pc.yellow(info.proxyPath)} ${pc.dim("\u2192")} ${pc.dim(`localhost:${info.port}`)}`
+  );
+  log("");
+  const stats = [
+    { label: "Endpoints", value: info.endpointCount, color: pc.blue },
+    { label: "Handlers", value: info.handlerCount, color: pc.green },
+    { label: "Seeds", value: info.seedCount, color: pc.magenta }
+  ];
+  const statsLine = stats.map((s) => `${pc.dim(`${s.label}:`)} ${s.color(String(s.value))}`).join(pc.dim("  \u2502  "));
+  log(`  ${statsLine}`);
+  log("");
+  if (info.devtools) {
+    log(
+      `  ${pc.bold(pc.white("DevTools:"))}   ${pc.cyan(`http://localhost:${info.port}/_devtools`)}`
+    );
+    log(`  ${pc.bold(pc.white("API Info:"))}   ${pc.cyan(`http://localhost:${info.port}/_api`)}`);
+    log("");
+  }
+  log(pc.dim("  Press Ctrl+C to stop the server"));
+  log("");
+}
+var ANSI_ESCAPE_REGEX = /\x1b\[[0-9;]*m/g;
+function centerText(text, width) {
+  const visibleLength = text.replace(ANSI_ESCAPE_REGEX, "").length;
+  const padding = Math.max(0, width - visibleLength);
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+}
+function extractBannerInfo(registry, document, handlerCount, seedCount, options) {
+  return {
+    port: options.port,
+    proxyPath: options.proxyPath,
+    title: document.info.title,
+    version: document.info.version,
+    endpointCount: registry.endpoints.size,
+    handlerCount,
+    seedCount,
+    devtools: options.devtools
+  };
+}
+function printReloadNotification(type, count, options) {
+  if (options.silent) {
+    return;
+  }
+  const logger = options.logger ?? console;
+  const icon = type === "handlers" ? "\u{1F504}" : "\u{1F331}";
+  const label = type === "handlers" ? "Handlers" : "Seeds";
+  const color = type === "handlers" ? pc.green : pc.magenta;
+  logger.info(`  ${icon} ${color(label)} reloaded: ${pc.bold(String(count))} ${type}`);
+}
+function printError(message, error, options) {
+  const logger = options.logger ?? console;
+  logger.error(`${pc.red("\u2716")} ${pc.bold(pc.red("Error:"))} ${message}`);
+  if (error instanceof Error) {
+    logger.error(pc.dim(`  ${error.message}`));
+  }
+}
+
+// src/utils.ts
+async function directoryExists(dirPath) {
+  try {
+    const fs = await import('fs/promises');
+    const stats = await fs.stat(dirPath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// 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 dirExists = await directoryExists(absoluteDir);
+  if (!dirExists) {
+    return {
+      handlers,
+      fileCount: 0,
+      files: []
+    };
+  }
+  const pattern = "**/*.handlers.{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 fileHandlers = await loadHandlerFile(absolutePath, viteServer, logger);
+    for (const [operationId, handler] of Object.entries(fileHandlers)) {
+      if (handlers.has(operationId)) {
+        logger.warn(
+          `[vite-plugin-open-api-server] Duplicate handler for operationId "${operationId}" in ${file}. Using last definition.`
+        );
+      }
+      handlers.set(operationId, handler);
+    }
+  }
+  return {
+    handlers,
+    fileCount: files.length,
+    files
+  };
+}
+async function loadHandlerFile(filePath, viteServer, logger) {
+  try {
+    const moduleNode = viteServer.moduleGraph.getModuleById(filePath);
+    if (moduleNode) {
+      viteServer.moduleGraph.invalidateModule(moduleNode);
+    }
+    const module = await viteServer.ssrLoadModule(filePath);
+    const handlers = module.default ?? module.handlers ?? module;
+    if (!handlers || typeof handlers !== "object") {
+      logger.warn(
+        `[vite-plugin-open-api-server] Invalid handler file ${filePath}: expected object export`
+      );
+      return {};
+    }
+    const validHandlers = {};
+    for (const [key, value] of Object.entries(handlers)) {
+      if (typeof value === "function") {
+        validHandlers[key] = value;
+      }
+    }
+    return validHandlers;
+  } catch (error) {
+    logger.error(
+      `[vite-plugin-open-api-server] Failed to load handler file ${filePath}:`,
+      error instanceof Error ? error.message : error
+    );
+    return {};
+  }
+}
+async function getHandlerFiles(handlersDir, cwd = process.cwd()) {
+  const absoluteDir = path2.resolve(cwd, handlersDir);
+  const dirExists = await directoryExists(absoluteDir);
+  if (!dirExists) {
+    return [];
+  }
+  const pattern = "**/*.handlers.{ts,js,mjs}";
+  const files = await fg(pattern, {
+    cwd: absoluteDir,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["node_modules/**", "dist/**"]
+  });
+  return files;
+}
+async function createFileWatcher(options) {
+  const {
+    handlersDir,
+    seedsDir,
+    onHandlerChange,
+    onSeedChange,
+    cwd = process.cwd(),
+    logger = console
+  } = options;
+  const { watch } = await import('chokidar');
+  const watchers = [];
+  const readyPromises = [];
+  let isWatching = true;
+  const handlerPattern = "**/*.handlers.{ts,js,mjs}";
+  const seedPattern = "**/*.seeds.{ts,js,mjs}";
+  const safeInvoke = (callback, filePath, context) => {
+    Promise.resolve().then(() => callback(filePath)).catch((error) => {
+      logger.error(
+        `[vite-plugin-open-api-server] ${context} callback error for ${filePath}:`,
+        error
+      );
+    });
+  };
+  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
+      }
+    });
+    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
+      }
+    });
+    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);
+  }
+  const readyPromise = Promise.all(readyPromises).then(() => {
+  });
+  return {
+    async close() {
+      isWatching = false;
+      await Promise.all(watchers.map((w) => w.close()));
+    },
+    get isWatching() {
+      return isWatching;
+    },
+    get ready() {
+      return readyPromise;
+    }
+  };
+}
+function debounce(fn, delay) {
+  let timeoutId = null;
+  let isRunning = false;
+  let pendingArgs = null;
+  const execute = async (...args) => {
+    if (isRunning) {
+      pendingArgs = args;
+      return;
+    }
+    isRunning = true;
+    try {
+      try {
+        await fn(...args);
+      } catch {
+      }
+    } finally {
+      isRunning = false;
+      if (pendingArgs !== null) {
+        const nextArgs = pendingArgs;
+        pendingArgs = null;
+        setTimeout(() => execute(...nextArgs), 0);
+      }
+    }
+  };
+  return (...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      execute(...args);
+    }, delay);
+  };
+}
+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/types.ts
+function resolveOptions(options) {
+  if (!options.spec || typeof options.spec !== "string" || options.spec.trim() === "") {
+    throw new Error(
+      "spec is required and must be a non-empty string (path or URL to OpenAPI spec)"
+    );
+  }
+  return {
+    spec: options.spec,
+    port: options.port ?? 4e3,
+    proxyPath: options.proxyPath ?? "/api",
+    handlersDir: options.handlersDir ?? "./mocks/handlers",
+    seedsDir: options.seedsDir ?? "./mocks/seeds",
+    enabled: options.enabled ?? true,
+    idFields: options.idFields ?? {},
+    timelineLimit: options.timelineLimit ?? 500,
+    devtools: options.devtools ?? true,
+    cors: options.cors ?? true,
+    corsOrigin: options.corsOrigin ?? "*",
+    silent: options.silent ?? false,
+    logger: options.logger
+  };
+}
+
+// src/plugin.ts
+function openApiServer(options) {
+  const resolvedOptions = resolveOptions(options);
+  let server = null;
+  let vite = null;
+  let fileWatcher = null;
+  let cwd = process.cwd();
+  return {
+    name: "vite-plugin-open-api-server",
+    // Only active in dev mode
+    apply: "serve",
+    /**
+     * Configure the Vite dev server
+     *
+     * This hook is called when the dev server is created.
+     * We use it to:
+     * 1. Start the OpenAPI mock server
+     * 2. Configure the Vite proxy to forward API requests
+     * 3. Set up file watching for hot reload
+     */
+    async configureServer(viteServer) {
+      vite = viteServer;
+      cwd = viteServer.config.root;
+      if (!resolvedOptions.enabled) {
+        return;
+      }
+      try {
+        const handlersResult = await loadHandlers(resolvedOptions.handlersDir, viteServer, cwd);
+        const seedsResult = await loadSeeds(resolvedOptions.seedsDir, viteServer, cwd);
+        server = await createOpenApiServer({
+          spec: resolvedOptions.spec,
+          port: resolvedOptions.port,
+          idFields: resolvedOptions.idFields,
+          handlers: handlersResult.handlers,
+          // Seeds are populated via executeSeeds, not directly
+          seeds: /* @__PURE__ */ new Map(),
+          timelineLimit: resolvedOptions.timelineLimit,
+          cors: resolvedOptions.cors,
+          corsOrigin: resolvedOptions.corsOrigin,
+          logger: resolvedOptions.logger
+        });
+        if (seedsResult.seeds.size > 0) {
+          await executeSeeds(seedsResult.seeds, server.store, server.document);
+        }
+        await server.start();
+        configureProxy(viteServer, resolvedOptions.proxyPath, resolvedOptions.port);
+        const bannerInfo = extractBannerInfo(
+          server.registry,
+          {
+            info: {
+              title: server.document.info?.title ?? "OpenAPI Server",
+              version: server.document.info?.version ?? "1.0.0"
+            }
+          },
+          handlersResult.handlers.size,
+          seedsResult.seeds.size,
+          resolvedOptions
+        );
+        printBanner(bannerInfo, resolvedOptions);
+        await setupFileWatching();
+      } catch (error) {
+        printError("Failed to start OpenAPI mock server", error, resolvedOptions);
+        throw error;
+      }
+    },
+    /**
+     * Clean up when Vite server closes
+     */
+    async closeBundle() {
+      await cleanup();
+    }
+    /**
+     * Handle HMR (Hot Module Replacement)
+     *
+     * Note: This is called for all HMR updates, not just our files.
+     * We handle our own file watching separately.
+     */
+    // handleHotUpdate is not needed - we use chokidar directly
+  };
+  function configureProxy(vite2, proxyPath, port) {
+    const serverConfig = vite2.config.server ?? {};
+    const proxyConfig = serverConfig.proxy ?? {};
+    const escapedPath = proxyPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    proxyConfig[proxyPath] = {
+      target: `http://localhost:${port}`,
+      changeOrigin: true,
+      // Remove the proxy path prefix when forwarding
+      rewrite: (path4) => path4.replace(new RegExp(`^${escapedPath}`), "")
+    };
+    if (vite2.config.server) {
+      vite2.config.server.proxy = proxyConfig;
+    }
+  }
+  async function setupFileWatching() {
+    if (!server || !vite) return;
+    const debouncedHandlerReload = debounce(reloadHandlers, 100);
+    const debouncedSeedReload = debounce(reloadSeeds, 100);
+    fileWatcher = await createFileWatcher({
+      handlersDir: resolvedOptions.handlersDir,
+      seedsDir: resolvedOptions.seedsDir,
+      cwd,
+      onHandlerChange: debouncedHandlerReload,
+      onSeedChange: debouncedSeedReload
+    });
+  }
+  async function reloadHandlers() {
+    if (!server || !vite) return;
+    try {
+      const handlersResult = await loadHandlers(resolvedOptions.handlersDir, vite, cwd);
+      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 reloadSeeds() {
+    if (!server || !vite) return;
+    try {
+      const seedsResult = await loadSeeds(resolvedOptions.seedsDir, vite, cwd);
+      if (seedsResult.seeds.size > 0) {
+        server.store.clearAll();
+        await executeSeeds(seedsResult.seeds, server.store, server.document);
+      } else {
+        server.store.clearAll();
+      }
+      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);
+    }
+  }
+  async function cleanup() {
+    if (fileWatcher) {
+      await fileWatcher.close();
+      fileWatcher = null;
+    }
+    if (server) {
+      await server.stop();
+      server = null;
+    }
+    vite = null;
+  }
+}
+
+export { createFileWatcher, debounce, getHandlerFiles, getSeedFiles, loadHandlers, loadSeeds, openApiServer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map