@cedarjs/vite 5.0.7-next.338 → 5.0.7

package/dist/cedar-unified-dev.js

@@ -3,39 +3,6 @@ import { createServer } from "vite";
 import yargsParser from "yargs-parser";
 import { getPaths, getConfig } from "@cedarjs/project-config";
 import { startApiDevMiddleware } from "./apiDevMiddleware.js";
-import { startJobsDevWorkers } from "./jobsDevMiddleware.js";
-const SHUTDOWN_TIMEOUT_MS = 5e3;
-function createShutdownHandler({
-  close,
-  timeoutMs = SHUTDOWN_TIMEOUT_MS,
-  exit = (code) => process.exit(code),
-  logger = console
-}) {
-  let shuttingDown = false;
-  return async function shutdown() {
-    if (shuttingDown) {
-      exit(0);
-      return;
-    }
-    shuttingDown = true;
-    const forceExitTimer = setTimeout(() => {
-      logger.warn(
-        `Dev server did not shut down within ${timeoutMs}ms. Forcing exit.`
-      );
-      exit(0);
-    }, timeoutMs);
-    forceExitTimer.unref();
-    try {
-      await close();
-    } catch (e) {
-      const message = e instanceof Error ? e.message : String(e);
-      logger.error(`Error while shutting down the dev server: ${message}`);
-    } finally {
-      clearTimeout(forceExitTimer);
-    }
-    exit(0);
-  };
-}
 function isViteInternalRequest(url) {
   const pathname = url.split("?")[0];
   return pathname.startsWith("/@") || pathname.startsWith("/__vite") || pathname.startsWith("/__hmr");
@@ -51,7 +18,6 @@ function parseCliArgs(argv = process.argv) {
     apiPort: _apiPortArg,
     "debug-port": debugPort,
     "debug-brk": debugBrk,
-    jobs: jobsArg,
     _: _positional,
     ...serverArgs
   } = yargsParser(argv.slice(2), {
@@ -62,20 +28,11 @@ function parseCliArgs(argv = process.argv) {
       "force",
       "cors",
       "debug",
-      "debug-brk",
-      "jobs"
+      "debug-brk"
     ],
     number: ["port", "apiPort", "debug-port"]
   });
-  return {
-    forceOptimize,
-    debug,
-    portArg,
-    debugPort,
-    debugBrk,
-    jobsArg,
-    serverArgs
-  };
+  return { forceOptimize, debug, portArg, debugPort, debugBrk, serverArgs };
 }
 async function clearPendingPause() {
   const inspector = await import("node:inspector");
@@ -223,29 +180,13 @@ async function startUnifiedDevServer() {
   if (!configFile) {
     throw new Error("Could not locate your web/vite.config.{js,ts} file");
   }
-  const {
-    forceOptimize,
-    debug,
-    portArg,
-    debugPort,
-    debugBrk,
-    jobsArg,
-    serverArgs
-  } = parseCliArgs();
-  if (serverArgs.open === void 0 && !process.stdout.isTTY) {
-    serverArgs.open = false;
-  }
+  const { forceOptimize, debug, portArg, debugPort, debugBrk, serverArgs } = parseCliArgs();
   if (debugPort !== void 0) {
     await openDebugger(debugPort, debugBrk);
   }
   const webPort = portArg ?? cedarConfig.web.port ?? 8910;
-  const {
-    viteServer: apiViteServer,
-    close: closeApi,
-    handler: apiHandler
-  } = await startApiDevMiddleware();
+  const { close: closeApi, handler: apiHandler } = await startApiDevMiddleware();
   const apiAdapter = createServerAdapter(apiHandler);
-  const jobsWorkerPool = jobsArg === false ? null : await startJobsDevWorkers(apiViteServer);
   const devServer = await createServer({
     configFile,
     // env file is handled by Cedar's plugins
@@ -318,21 +259,15 @@ async function startUnifiedDevServer() {
     console.log(JSON.stringify(devServer.config, null, 2));
     console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~");
   }
-  const shutdown = createShutdownHandler({
-    close: async () => {
-      await devServer.close();
-      try {
-        await jobsWorkerPool?.stop();
-      } finally {
-        await closeApi();
-      }
-    }
-  });
+  const shutdown = async () => {
+    await devServer.close();
+    await closeApi();
+    process.exit(0);
+  };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
 export {
-  createShutdownHandler,
   openDebugger,
   parseCliArgs,
   startUnifiedDevServer

package/dist/cjs/ClientRouter.d.ts

@@ -0,0 +1 @@
+export type * from "../ClientRouter.d.ts"

package/dist/cjs/api/vite-plugin-cedar-vitest-api-preset.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_vitest_api_preset_exports = {};
+__export(vite_plugin_cedar_vitest_api_preset_exports, {
+  cedarVitestPreset: () => cedarVitestPreset
+});
+module.exports = __toCommonJS(vite_plugin_cedar_vitest_api_preset_exports);
+var import_vitest = require("@cedarjs/testing/api/vitest");
+var import_vite_plugin_cedarjs_resolve_cedar_style_imports = require("../plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js");
+function cedarVitestPreset() {
+  return [
+    (0, import_vitest.cedarVitestApiConfigPlugin)(),
+    (0, import_vitest.autoImportsPlugin)(),
+    (0, import_vite_plugin_cedarjs_resolve_cedar_style_imports.cedarjsResolveCedarStyleImportsPlugin)(),
+    (0, import_vitest.trackDbImportsPlugin)()
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarVitestPreset
+});

package/dist/cjs/apiDevMiddleware.js

@@ -0,0 +1,371 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var apiDevMiddleware_exports = {};
+__export(apiDevMiddleware_exports, {
+  createApiFetchHandler: () => createApiFetchHandler,
+  createApiViteServer: () => createApiViteServer,
+  loadApiFunctions: () => loadApiFunctions,
+  setupHmrHandlers: () => setupHmrHandlers,
+  startApiDevMiddleware: () => startApiDevMiddleware
+});
+module.exports = __toCommonJS(apiDevMiddleware_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_ansis = __toESM(require("ansis"), 1);
+var import_vite = require("vite");
+var import_runtime = require("@cedarjs/api/runtime");
+var import_babel_config = require("@cedarjs/babel-config");
+var import_store = require("@cedarjs/context/dist/store");
+var import_graphql_server = require("@cedarjs/graphql-server");
+var import_project_config = require("@cedarjs/project-config");
+var import_workspacePackageAliases = require("./lib/workspacePackageAliases.js");
+const LAMBDA_FUNCTIONS = {};
+let graphqlYoga = null;
+let loadApiFunctionsInFlight = null;
+let needsReloadAfterInFlight = false;
+async function loadApiFunctions(viteServer) {
+  if (loadApiFunctionsInFlight) {
+    needsReloadAfterInFlight = true;
+    return;
+  }
+  do {
+    needsReloadAfterInFlight = false;
+    loadApiFunctionsInFlight = internalLoadApiFunctions(viteServer);
+    try {
+      await loadApiFunctionsInFlight;
+    } finally {
+      loadApiFunctionsInFlight = null;
+    }
+  } while (needsReloadAfterInFlight);
+}
+async function internalLoadApiFunctions(viteServer) {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  for (const key of Object.keys(LAMBDA_FUNCTIONS)) {
+    delete LAMBDA_FUNCTIONS[key];
+  }
+  let srcFunctions = [];
+  try {
+    srcFunctions = await Array.fromAsync(
+      (0, import_promises.glob)("**/*.{ts,tsx,js,jsx}", {
+        cwd: cedarPaths.api.functions,
+        exclude: [
+          "**/*.test.{ts,tsx,js,jsx}",
+          "**/*.scenarios.{ts,tsx,js,jsx}",
+          "**/*.fixtures.{ts,tsx,js,jsx}",
+          "**/*.d.ts"
+        ]
+      }),
+      (entry) => import_node_path.default.join(cedarPaths.api.functions, entry)
+    );
+  } catch {
+    srcFunctions = [];
+  }
+  console.log(import_ansis.default.dim.italic("Importing Server Functions... "));
+  const tsImport = Date.now();
+  let extractedGraphqlOptions = null;
+  const imports = srcFunctions.map(async (fnPath) => {
+    const ts = Date.now();
+    const routeName = import_node_path.default.basename(fnPath).replace(/\.(ts|tsx|js|jsx)$/, "");
+    try {
+      const mod = await viteServer.ssrLoadModule((0, import_node_url.pathToFileURL)(fnPath).href);
+      const cedarHandler = (() => {
+        if ("handleRequest" in mod) {
+          return mod.handleRequest;
+        }
+        if ("default" in mod && mod.default && "handleRequest" in mod.default) {
+          return mod.default.handleRequest;
+        }
+        let legacyHandler;
+        if ("handler" in mod) {
+          legacyHandler = mod.handler;
+        } else if ("default" in mod && mod.default && "handler" in mod.default) {
+          legacyHandler = mod.default.handler;
+        }
+        if (legacyHandler) {
+          return (0, import_runtime.wrapLegacyHandler)(legacyHandler);
+        }
+        return void 0;
+      })();
+      if (cedarHandler) {
+        LAMBDA_FUNCTIONS[routeName] = cedarHandler;
+        console.log(
+          import_ansis.default.magenta("/" + routeName),
+          import_ansis.default.dim.italic(Date.now() - ts + " ms")
+        );
+      } else {
+        console.warn(
+          `[apiDevMiddleware] No handler or handleRequest export found in function: ${fnPath}`
+        );
+      }
+      if (routeName === "graphql" && "__cedar_graphqlOptions" in mod) {
+        extractedGraphqlOptions = mod.__cedar_graphqlOptions;
+      }
+    } catch (err) {
+      viteServer.ssrFixStacktrace(err);
+      console.error(
+        `[apiDevMiddleware] Failed to load function "${routeName}" from ${fnPath}:`,
+        err
+      );
+    }
+  });
+  await Promise.all(imports);
+  if (extractedGraphqlOptions) {
+    const { yoga } = await (0, import_graphql_server.createGraphQLYoga)(extractedGraphqlOptions);
+    graphqlYoga = yoga;
+  } else {
+    graphqlYoga = null;
+  }
+  console.log(
+    import_ansis.default.dim.italic("...Done importing in " + (Date.now() - tsImport) + " ms")
+  );
+}
+async function createApiViteServer() {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const isEsm = (0, import_project_config.projectSideIsEsm)("api");
+  const normalizedBase = (0, import_vite.normalizePath)(cedarPaths.base);
+  const babelPlugins = (0, import_babel_config.getApiSideBabelPlugins)({
+    openTelemetry: (cedarConfig.experimental?.opentelemetry?.enabled ?? false) && (cedarConfig.experimental?.opentelemetry?.wrapApi ?? false),
+    projectIsEsm: isEsm
+  });
+  const workspacePkgSourceMap = Object.fromEntries(
+    Object.entries((0, import_workspacePackageAliases.getWorkspacePackageAliases)(cedarPaths, cedarConfig)).map(
+      ([name, sourceFile]) => [name, (0, import_vite.normalizePath)(sourceFile)]
+    )
+  );
+  const { createServer: createViteServer } = await import("vite");
+  return createViteServer({
+    configFile: false,
+    root: cedarPaths.api.base,
+    appType: "custom",
+    clearScreen: false,
+    logLevel: "warn",
+    server: {
+      middlewareMode: true
+    },
+    resolve: {
+      alias: workspacePkgSourceMap
+    },
+    plugins: [
+      {
+        name: "cedar-api-babel-transform",
+        enforce: "pre",
+        async transform(code, id) {
+          if (!/\.(ts|tsx|js|jsx)$/.test(id)) {
+            return null;
+          }
+          if (id.includes("node_modules")) {
+            return null;
+          }
+          if (!id.startsWith(normalizedBase)) {
+            return null;
+          }
+          try {
+            const result = await (0, import_babel_config.transformWithBabel)(
+              code,
+              id,
+              babelPlugins,
+              true
+            );
+            if (!result?.code) {
+              return null;
+            }
+            return {
+              code: result.code,
+              map: result.map ?? null
+            };
+          } catch (err) {
+            this.warn(
+              `[cedar-api-babel-transform] Failed to transform ${id}: ${String(err)}`
+            );
+            return null;
+          }
+        }
+      }
+    ]
+  });
+}
+function invalidateApiModules(viteServer, normalizedApiSrc) {
+  const invalidated = /* @__PURE__ */ new Set();
+  const invalidateWithImporters = (mod) => {
+    if (!mod || invalidated.has(mod.id ?? mod.url)) {
+      return;
+    }
+    invalidated.add(mod.id ?? mod.url);
+    viteServer.moduleGraph.invalidateModule(mod);
+    for (const importer of mod.importers) {
+      invalidateWithImporters(importer);
+    }
+  };
+  for (const mod of viteServer.moduleGraph.idToModuleMap.values()) {
+    if (mod.id?.startsWith(normalizedApiSrc)) {
+      invalidateWithImporters(mod);
+    }
+  }
+}
+function setupHmrHandlers(viteServer) {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const normalizedApiSrc = (0, import_vite.normalizePath)(cedarPaths.api.src);
+  const normalizedApiBase = (0, import_vite.normalizePath)(cedarPaths.api.base);
+  viteServer.watcher.on("change", async (filePath) => {
+    const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    const displayPath = import_node_path.default.relative(normalizedApiBase, normalizedFilePath);
+    console.log(import_ansis.default.dim(`[change] ${displayPath}`));
+    const fileUrl = (0, import_node_url.pathToFileURL)(normalizedFilePath).href;
+    const mod = viteServer.moduleGraph.getModuleById(normalizedFilePath) ?? viteServer.moduleGraph.getModuleById(fileUrl);
+    if (mod) {
+      const invalidated = /* @__PURE__ */ new Set();
+      const invalidateWithImporters = (m) => {
+        if (!m || invalidated.has(m.id ?? m.url)) {
+          return;
+        }
+        invalidated.add(m.id ?? m.url);
+        viteServer.moduleGraph.invalidateModule(m);
+        for (const importer of m.importers) {
+          invalidateWithImporters(importer);
+        }
+      };
+      invalidateWithImporters(mod);
+    }
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("add", async (filePath) => {
+    const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      import_ansis.default.dim(
+        `[add] ${import_node_path.default.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("unlink", async (filePath) => {
+    const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      import_ansis.default.dim(
+        `[unlink] ${import_node_path.default.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+}
+function createApiFetchHandler() {
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const apiUrlPrefix = cedarConfig.web.apiUrl.replace(/\/$/, "");
+  return async (request) => {
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+    if (pathname.startsWith(apiUrlPrefix + "/")) {
+      pathname = pathname.slice(apiUrlPrefix.length);
+    } else if (pathname === apiUrlPrefix) {
+      pathname = "/";
+    }
+    if (pathname === "/graphql" || pathname.startsWith("/graphql/")) {
+      if (!graphqlYoga) {
+        return new Response(
+          JSON.stringify({ error: "GraphQL Yoga instance not initialized" }),
+          { status: 503, headers: { "Content-Type": "application/json" } }
+        );
+      }
+      const yoga = graphqlYoga;
+      return (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), async () => {
+        try {
+          return await yoga.handle(request, { request });
+        } catch (e) {
+          if (!!e && typeof e === "object" && "code" in e && e.code === "ERR_STREAM_PREMATURE_CLOSE") {
+            return new Response(null, { status: 499 });
+          }
+          throw e;
+        }
+      });
+    }
+    const match = pathname.match(/^\/([^/]+)(?:\/.*)?$/);
+    if (!match) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const routeName = match[1];
+    const handler = LAMBDA_FUNCTIONS[routeName];
+    if (!handler) {
+      return new Response(
+        JSON.stringify({
+          error: `Function "${routeName}" was not found.`,
+          availableFunctions: Object.keys(LAMBDA_FUNCTIONS)
+        }),
+        { status: 404, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    try {
+      const ctx = await (0, import_runtime.buildCedarContext)(request, {
+        params: { routeName }
+      });
+      return await handler(request, ctx);
+    } catch (err) {
+      console.error(
+        `[apiDevMiddleware] Error handling function "${routeName}":`,
+        err
+      );
+      return new Response(
+        JSON.stringify({
+          error: err instanceof Error ? err.message : "Internal Server Error"
+        }),
+        { status: 500, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  };
+}
+async function startApiDevMiddleware() {
+  const viteServer = await createApiViteServer();
+  console.log(import_ansis.default.dim.italic("Starting API dev server..."));
+  await loadApiFunctions(viteServer);
+  setupHmrHandlers(viteServer);
+  const close = async () => {
+    await viteServer.close();
+  };
+  const handler = createApiFetchHandler();
+  return { viteServer, close, handler };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApiFetchHandler,
+  createApiViteServer,
+  loadApiFunctions,
+  setupHmrHandlers,
+  startApiDevMiddleware
+});

package/dist/cjs/build/build.d.ts

@@ -0,0 +1 @@
+export type * from "../../build/build.d.ts"

package/dist/cjs/build/build.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var build_exports = {};
+__export(build_exports, {
+  buildCedarApp: () => import_buildApp.buildCedarApp,
+  buildWeb: () => buildWeb
+});
+module.exports = __toCommonJS(build_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_buildApp = require("../buildApp.js");
+const buildWeb = async ({ verbose }) => {
+  const { build } = await import("vite");
+  const viteConfig = (0, import_project_config.getPaths)().web.viteConfig;
+  if (process.cwd() !== (0, import_project_config.getPaths)().web.base) {
+    throw new Error(
+      "Looks like you are running the command from the wrong dir, this can lead to unintended consequences on CSS processing"
+    );
+  }
+  if (!viteConfig) {
+    throw new Error("Could not locate your web/vite.config.{js,ts} file");
+  }
+  return build({
+    configFile: viteConfig,
+    envFile: false,
+    logLevel: verbose ? "info" : "warn"
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCedarApp,
+  buildWeb
+});