@cedarjs/vite 4.1.1-next.1 → 4.1.1-next.55

package/dist/cjs/cedar-unified-dev.js

@@ -22,11 +22,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var import_server = require("@whatwg-node/server");
 var import_vite = require("vite");
 var import_yargs_parser = __toESM(require("yargs-parser"), 1);
 var import_project_config = require("@cedarjs/project-config");
-var import_apiDevServer = require("./apiDevServer.js");
+var import_apiDevMiddleware = require("./apiDevMiddleware.js");
+function isViteInternalRequest(url) {
+  const pathname = url.split("?")[0];
+  return pathname.startsWith("/@") || pathname.startsWith("/__vite") || pathname.startsWith("/__hmr");
+}
+function isApiRequest(url, apiUrl, apiGqlUrl) {
+  return url === apiUrl || url.startsWith(apiUrl + "/") || url.startsWith(apiUrl + "?") || url === apiGqlUrl || url.startsWith(apiGqlUrl + "/") || url.startsWith(apiGqlUrl + "?");
+}
 const startUnifiedDevServer = async () => {
+  process.env.__CEDAR_UNIFIED_DEV = "true";
   const rwPaths = (0, import_project_config.getPaths)();
   const cedarConfig = (0, import_project_config.getConfig)();
   const configFile = rwPaths.web.viteConfig;
@@ -37,7 +46,7 @@ const startUnifiedDevServer = async () => {
     force: forceOptimize,
     debug,
     port: portArg,
-    apiPort: apiPortArg,
+    apiPort: _apiPortArg,
     _: _positional,
     ...serverArgs
   } = (0, import_yargs_parser.default)(process.argv.slice(2), {
@@ -45,8 +54,8 @@ const startUnifiedDevServer = async () => {
     number: ["port", "apiPort"]
   });
   const webPort = portArg ?? cedarConfig.web.port ?? 8910;
-  const apiPort = apiPortArg ?? cedarConfig.api.port ?? 8911;
-  const { close: closeApi } = await (0, import_apiDevServer.startApiDevServer)(apiPort);
+  const { close: closeApi, handler: apiHandler } = await (0, import_apiDevMiddleware.startApiDevMiddleware)();
+  const apiAdapter = (0, import_server.createServerAdapter)(apiHandler);
   const devServer = await (0, import_vite.createServer)({
     configFile,
     // env file is handled by Cedar's plugins
@@ -59,7 +68,52 @@ const startUnifiedDevServer = async () => {
       port: webPort,
       ...serverArgs
     },
-    logLevel: debug ? "info" : void 0
+    logLevel: debug ? "info" : void 0,
+    plugins: [
+      {
+        name: "cedar-api-middleware",
+        apply: "serve",
+        configureServer(server) {
+          const apiUrl = cedarConfig.web.apiUrl.replace(/\/$/, "");
+          const apiGqlUrl = cedarConfig.web.apiGraphQLUrl ?? apiUrl + "/graphql";
+          server.middlewares.use(
+            async (req, res, next) => {
+              const url = req.url ?? "/";
+              if (isViteInternalRequest(url)) {
+                return next();
+              }
+              if (!isApiRequest(url, apiUrl, apiGqlUrl)) {
+                return next();
+              }
+              try {
+                await apiAdapter(req, res);
+              } catch (err) {
+                console.error(
+                  "[cedar-api-middleware] Error handling API request:",
+                  err
+                );
+                if (!res.headersSent) {
+                  res.writeHead(500, { "Content-Type": "application/json" });
+                }
+                res.end(
+                  JSON.stringify(
+                    {
+                      errors: [
+                        {
+                          message: err instanceof Error ? err.message : "Internal Server Error"
+                        }
+                      ]
+                    },
+                    null,
+                    2
+                  )
+                );
+              }
+            }
+          );
+        }
+      }
+    ]
   });
   await devServer.listen();
   process.stdin.on("data", async (data) => {

package/dist/cjs/index.js

@@ -31,7 +31,7 @@ __export(index_exports, {
   cedar: () => cedar,
   cedarAutoImportsPlugin: () => import_vite_plugin_cedar_auto_import.cedarAutoImportsPlugin,
   cedarCellTransform: () => import_vite_plugin_cedar_cell2.cedarCellTransform,
-  cedarDevDispatcherPlugin: () => import_vite_plugin_cedar_dev_dispatcher.cedarDevDispatcherPlugin,
+  cedarCjsCompatPlugin: () => import_vite_plugin_cedar_cjs_compat.cedarCjsCompatPlugin,
   cedarEntryInjectionPlugin: () => import_vite_plugin_cedar_entry_injection2.cedarEntryInjectionPlugin,
   cedarHtmlEnvPlugin: () => import_vite_plugin_cedar_html_env2.cedarHtmlEnvPlugin,
   cedarImportDirPlugin: () => import_vite_plugin_cedar_import_dir.cedarImportDirPlugin,
@@ -62,6 +62,7 @@ var import_vite_plugin_jsx_loader = require("./plugins/vite-plugin-jsx-loader.js
 var import_vite_plugin_merged_config = require("./plugins/vite-plugin-merged-config.js");
 var import_vite_plugin_swap_apollo_provider = require("./plugins/vite-plugin-swap-apollo-provider.js");
 var import_vite_plugin_cedar_auto_import = require("./plugins/vite-plugin-cedar-auto-import.js");
+var import_vite_plugin_cedar_cjs_compat = require("./plugins/vite-plugin-cedar-cjs-compat.js");
 var import_vite_plugin_cedar_cell2 = require("./plugins/vite-plugin-cedar-cell.js");
 var import_vite_plugin_cedar_entry_injection2 = require("./plugins/vite-plugin-cedar-entry-injection.js");
 var import_vite_plugin_cedar_html_env2 = require("./plugins/vite-plugin-cedar-html-env.js");
@@ -74,7 +75,6 @@ var import_vite_plugin_jsx_loader2 = require("./plugins/vite-plugin-jsx-loader.j
 var import_vite_plugin_merged_config2 = require("./plugins/vite-plugin-merged-config.js");
 var import_vite_plugin_swap_apollo_provider2 = require("./plugins/vite-plugin-swap-apollo-provider.js");
 var import_vite_plugin_cedar_universal_deploy = require("./plugins/vite-plugin-cedar-universal-deploy.js");
-var import_vite_plugin_cedar_dev_dispatcher = require("./plugins/vite-plugin-cedar-dev-dispatcher.js");
 var import_vite_plugin_cedar_wait_for_api_server2 = require("./plugins/vite-plugin-cedar-wait-for-api-server.js");
 function cedar({ mode } = {}) {
   const cedarConfig = (0, import_project_config.getConfig)();
@@ -115,7 +115,7 @@ var index_default = cedar;
   cedar,
   cedarAutoImportsPlugin,
   cedarCellTransform,
-  cedarDevDispatcherPlugin,
+  cedarCjsCompatPlugin,
   cedarEntryInjectionPlugin,
   cedarHtmlEnvPlugin,
   cedarImportDirPlugin,

package/dist/cjs/plugins/vite-plugin-cedar-cjs-compat.js

@@ -0,0 +1,341 @@
+"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 vite_plugin_cedar_cjs_compat_exports = {};
+__export(vite_plugin_cedar_cjs_compat_exports, {
+  cedarCjsCompatPlugin: () => cedarCjsCompatPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_cjs_compat_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_acorn = require("acorn");
+const UMD_REGEXES = [
+  /\btypeof\s+(module\.exports|module|exports)\s*===?\s*['"]object['"]/,
+  /['"]object['"]\s*===?\s*typeof\s+(module\.exports|module|exports)/,
+  /\btypeof\s+define\s*===?\s*['"]function['"]/,
+  /['"]function['"]\s*===?\s*typeof\s+define/
+];
+function isAstNode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+function hasProperty(obj, key) {
+  return key in obj;
+}
+function walkAst(node, visitor) {
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      walkAst(child, visitor);
+    }
+    return;
+  }
+  if (!isAstNode(node)) {
+    return;
+  }
+  const shouldDescend = visitor(node);
+  if (shouldDescend === false) {
+    return;
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "loc" || key === "range") {
+      continue;
+    }
+    const child = node[key];
+    if (child && typeof child === "object") {
+      walkAst(child, visitor);
+    }
+  }
+}
+function getIdentifierName(node) {
+  if (!isAstNode(node)) {
+    return null;
+  }
+  return node.type === "Identifier" && typeof node.name === "string" ? node.name : null;
+}
+function isModuleExports(node) {
+  if (!isAstNode(node)) {
+    return false;
+  }
+  return node.type === "MemberExpression" && getIdentifierName(node.object) === "module" && getIdentifierName(node.property) === "exports";
+}
+function isReExport(node) {
+  if (!isAstNode(node) || node.type !== "AssignmentExpression") {
+    return false;
+  }
+  return isModuleExports(node.left) && isAstNode(node.right) && node.right.type === "CallExpression" && getIdentifierName(node.right.callee) === "require";
+}
+function isObjectDefinePropertyWithGetterOnExports(node) {
+  if (!isAstNode(node) || node.type !== "CallExpression") {
+    return false;
+  }
+  if (!isObjectDefineProperty(node)) {
+    return false;
+  }
+  const args = node.arguments;
+  if (!Array.isArray(args) || args.length < 3 || getIdentifierName(args[0]) !== "exports") {
+    return false;
+  }
+  const descriptor = args[2];
+  if (!isAstNode(descriptor) || descriptor.type !== "ObjectExpression") {
+    return false;
+  }
+  const props = descriptor.properties;
+  if (!Array.isArray(props)) {
+    return false;
+  }
+  return props.some((prop) => {
+    if (!isAstNode(prop) || prop.type !== "Property") {
+      return false;
+    }
+    const name = getIdentifierName(prop.key);
+    return name === "get" || name === "set";
+  });
+}
+function getModuleExportsObjectLiteral(node) {
+  if (!isAstNode(node) || node.type !== "AssignmentExpression") {
+    return null;
+  }
+  if (isModuleExports(node.left) && isAstNode(node.right) && node.right.type === "ObjectExpression") {
+    return node.right;
+  }
+  return null;
+}
+function isObjectDefineProperty(node) {
+  if (!isAstNode(node) || node.type !== "CallExpression") {
+    return false;
+  }
+  const callee = node.callee;
+  if (!isAstNode(callee) || callee.type !== "MemberExpression") {
+    return false;
+  }
+  return getIdentifierName(callee.object) === "Object" && getIdentifierName(callee.property) === "defineProperty";
+}
+function formatLoc(node) {
+  const loc = node.loc;
+  if (typeof loc !== "object" || loc === null || !hasProperty(loc, "start")) {
+    return "unknown location";
+  }
+  const start = loc.start;
+  if (typeof start !== "object" || start === null || !hasProperty(start, "line") || !hasProperty(start, "column")) {
+    return "unknown location";
+  }
+  const line = start.line;
+  const column = start.column;
+  if (typeof line !== "number" || typeof column !== "number") {
+    return "unknown location";
+  }
+  return `line ${line}, column ${column}`;
+}
+function cedarCjsCompatPlugin() {
+  let lexerInitialized = false;
+  return {
+    name: "cedar-cjs-compat",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!/\.[cm]?js$/.test(id)) {
+        return null;
+      }
+      if (!/\bmodule\.exports\b|\bexports\.[a-zA-Z_$]/.test(code)) {
+        return null;
+      }
+      const isUmd = UMD_REGEXES.some((re) => re.test(code));
+      if (isUmd) {
+        throw new Error(
+          `CedarJS CJS compat plugin does not support UMD modules. File: ${id}
+If you need to load this file in a Vite RunnableDevEnvironment, consider converting it to pure ESM or using a pre-bundled ESM build from the package author.`
+        );
+      }
+      let ast;
+      try {
+        ast = (0, import_acorn.parse)(code, { ecmaVersion: "latest", sourceType: "script" });
+      } catch {
+        return null;
+      }
+      function scanForUnsupportedPatterns(astBody) {
+        let objectLiteral = null;
+        walkAst(astBody, (node) => {
+          if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+            return false;
+          }
+          if (node.type !== "ExpressionStatement") {
+            return void 0;
+          }
+          const expr = node.expression;
+          if (!isAstNode(expr)) {
+            return void 0;
+          }
+          if (isReExport(expr)) {
+            throw new Error(
+              `CedarJS CJS compat plugin does not support re-exports (module.exports = require(...)). File: ${id}
+Named exports from the re-exported module would be lost. Convert the file to explicit named exports, or import the target module directly in the consumer.`
+            );
+          }
+          if (isObjectDefinePropertyWithGetterOnExports(expr)) {
+            throw new Error(
+              `CedarJS CJS compat plugin does not support Object.defineProperty with getter/setter descriptors on exports because they would be evaluated eagerly at load time rather than lazily. File: ${id}
+Convert the file to plain property assignments (exports.foo = ...) or use an ESM build of the package.`
+            );
+          }
+          const objectLiteralExpr = getModuleExportsObjectLiteral(expr);
+          if (objectLiteralExpr) {
+            objectLiteral = objectLiteralExpr;
+            return false;
+          }
+          return void 0;
+        });
+        return objectLiteral;
+      }
+      const objectLiteralAssignment = scanForUnsupportedPatterns(ast);
+      walkAst(ast, (node) => {
+        if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+          return false;
+        }
+        if (node.type !== "VariableDeclaration") {
+          return void 0;
+        }
+        const declarations = node.declarations;
+        if (!Array.isArray(declarations)) {
+          return void 0;
+        }
+        for (const decl of declarations) {
+          if (!isAstNode(decl)) {
+            continue;
+          }
+          const declId = decl.id;
+          if (!isAstNode(declId)) {
+            continue;
+          }
+          if (declId.type === "Identifier" && typeof declId.name === "string" && declId.name === "exports") {
+            throw new Error(
+              `CedarJS CJS compat plugin does not support local variables named 'exports' because they shadow the injected CJS globals. File: ${id}
+Rename the local variable to something else.`
+            );
+          }
+          if (declId.type === "ObjectPattern") {
+            const props = declId.properties;
+            if (Array.isArray(props)) {
+              for (const prop of props) {
+                if (isAstNode(prop) && prop.type === "Property" && getIdentifierName(prop.value) === "exports") {
+                  throw new Error(
+                    `CedarJS CJS compat plugin does not support destructuring into a local variable named 'exports' because it shadows the injected CJS globals. File: ${id}
+Rename the local variable to something else.`
+                  );
+                }
+              }
+            }
+          }
+        }
+        return void 0;
+      });
+      let namedExports = [];
+      try {
+        if (!lexerInitialized) {
+          const { init } = await import("cjs-module-lexer");
+          await init();
+          lexerInitialized = true;
+        }
+        const { parse: parseLexer } = await import("cjs-module-lexer");
+        const { exports: exports2 } = parseLexer(code);
+        namedExports = exports2.filter(
+          (e) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(e) && e !== "default"
+        );
+      } catch {
+      }
+      if (namedExports.length === 0 && objectLiteralAssignment) {
+        const props = objectLiteralAssignment.properties;
+        if (Array.isArray(props)) {
+          for (const prop of props) {
+            if (!isAstNode(prop)) {
+              continue;
+            }
+            if (prop.type === "SpreadElement") {
+              throw new Error(
+                `CedarJS CJS compat plugin encountered an unsupported pattern in module.exports = { ... } at ${formatLoc(prop)} (spread element (...)). File: ${id}
+Convert the object literal to plain property assignments (exports.foo = ...) so that cjs-module-lexer can detect the named exports, or use an ESM build of the package.`
+              );
+            }
+            if (prop.computed) {
+              throw new Error(
+                `CedarJS CJS compat plugin encountered an unsupported pattern in module.exports = { ... } at ${formatLoc(prop)} (computed property key ([expr])). File: ${id}
+Convert the object literal to plain property assignments (exports.foo = ...) so that cjs-module-lexer can detect the named exports, or use an ESM build of the package.`
+              );
+            }
+            if (prop.method) {
+              throw new Error(
+                `CedarJS CJS compat plugin encountered an unsupported pattern in module.exports = { ... } at ${formatLoc(prop)} (method shorthand). File: ${id}
+Convert the object literal to plain property assignments (exports.foo = ...) so that cjs-module-lexer can detect the named exports, or use an ESM build of the package.`
+              );
+            }
+            if (prop.shorthand) {
+              throw new Error(
+                `CedarJS CJS compat plugin encountered an unsupported pattern in module.exports = { ... } at ${formatLoc(prop)} (shorthand property). File: ${id}
+Convert the object literal to plain property assignments (exports.foo = ...) so that cjs-module-lexer can detect the named exports, or use an ESM build of the package.`
+              );
+            }
+            const keyName = getIdentifierName(prop.key);
+            if (keyName && keyName !== "default") {
+              namedExports.push(keyName);
+            }
+          }
+        }
+      }
+      const dirPath = JSON.stringify(import_node_path.default.dirname(id));
+      const filePath = JSON.stringify(id);
+      const hasEsModuleFlag = namedExports.includes("__esModule");
+      const safeNamedExports = namedExports.filter(
+        (e) => e !== "__esModule" && e !== "default"
+      );
+      const namedExportLines = safeNamedExports.map(
+        (name) => `export const ${name} = __cjs_result__[${JSON.stringify(name)}]`
+      ).join("\n");
+      const defaultExportLine = hasEsModuleFlag ? `export default (__cjs_result__ != null && typeof __cjs_result__ === 'object' && 'default' in __cjs_result__ ? __cjs_result__.default : __cjs_result__)` : `export default __cjs_result__`;
+      return {
+        code: `
+          import { createRequire as __createRequire__ } from 'node:module'
+          const require = __createRequire__(${filePath})
+          const module = { exports: {} }
+          const exports = module.exports
+          const __dirname = ${dirPath}
+          const __filename = ${filePath}
+          ;(function() {
+          ${code}
+          }).call(module.exports)
+          const __cjs_result__ = module.exports
+          ${defaultExportLine}
+          ${namedExportLines}
+        `,
+        // Source maps are not generated. If you hit a break-point issue inside
+        // a CJS file loaded through this plugin, the line numbers will be off
+        // by the number of lines in the wrapper preamble (~10).
+        map: null
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarCjsCompatPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-universal-deploy.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,48 +17,141 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 vite_plugin_cedar_universal_deploy_exports = {};
 __export(vite_plugin_cedar_universal_deploy_exports, {
   cedarUniversalDeployPlugin: () => cedarUniversalDeployPlugin
 });
 module.exports = __toCommonJS(vite_plugin_cedar_universal_deploy_exports);
+var import_node_path = __toESM(require("node:path"), 1);
 var import_store = require("@universal-deploy/store");
-const VIRTUAL_CEDAR_API = "virtual:cedar-api";
-const RESOLVED_VIRTUAL_CEDAR_API = "\0virtual:cedar-api";
+var import_files = require("@cedarjs/internal/dist/files.js");
+var import_project_config = require("@cedarjs/project-config");
+const VIRTUAL_CEDAR_FN_PREFIX = "virtual:cedar-api:fn:";
+const RESOLVED_CEDAR_FN_PREFIX = "\0virtual:cedar-api:fn:";
+const GRAPHQL_METHODS = ["GET", "POST", "OPTIONS"];
+function normaliseApiPrefix(apiPrefix) {
+  apiPrefix = apiPrefix.trim();
+  while (apiPrefix.startsWith("/")) {
+    apiPrefix = apiPrefix.slice(1);
+  }
+  while (apiPrefix.endsWith("/")) {
+    apiPrefix = apiPrefix.slice(0, -1);
+  }
+  return apiPrefix ? "/" + apiPrefix : "";
+}
+function discoverCedarRoutes(apiRootPath) {
+  const srcFunctions = (0, import_project_config.getPaths)().api.functions;
+  const distFunctions = import_node_path.default.join((0, import_project_config.getPaths)().api.base, "dist", "functions");
+  const sourceFiles = (0, import_files.findApiServerFunctions)(srcFunctions);
+  const routes = [];
+  for (const sourcePath of sourceFiles) {
+    const relative = import_node_path.default.relative(srcFunctions, sourcePath);
+    const { dir, name, ext: _ext } = import_node_path.default.parse(relative);
+    let routeName;
+    if (dir === name) {
+      routeName = dir;
+    } else if (dir === "") {
+      routeName = name;
+    } else if (dir.length && name === "index") {
+      routeName = dir;
+    } else {
+      continue;
+    }
+    const apiPrefix = normaliseApiPrefix(apiRootPath);
+    const routePath = routeName === "graphql" ? `${apiPrefix}/graphql` : `${apiPrefix}/${routeName}`;
+    const methods = routeName === "graphql" ? [...GRAPHQL_METHODS] : [];
+    const type = routeName === "graphql" ? "graphql" : routeName === "health" ? "health" : routeName.toLowerCase().includes("auth") ? "auth" : "function";
+    const distPath = import_node_path.default.join(distFunctions, dir, name + ".js");
+    routes.push({
+      id: routePath,
+      path: routePath,
+      methods,
+      type,
+      entry: distPath
+    });
+  }
+  const gqlIndex = routes.findIndex((r) => r.type === "graphql");
+  if (gqlIndex > 0) {
+    const [gqlRoute] = routes.splice(gqlIndex, 1);
+    routes.unshift(gqlRoute);
+  }
+  return routes;
+}
+function toEntryMeta(route) {
+  const routePatterns = route.path === "/**" ? ["/**"] : [route.path, `${route.path}/**`];
+  return {
+    id: `${VIRTUAL_CEDAR_FN_PREFIX}${route.id}`,
+    route: routePatterns,
+    ...route.methods.length > 0 && {
+      method: route.methods
+    }
+  };
+}
 function cedarUniversalDeployPlugin(options = {}) {
   const { apiRootPath } = options;
+  const routes = discoverCedarRoutes(apiRootPath ?? "/");
+  let entriesInjected = false;
   return {
     name: "cedar-universal-deploy",
     apply: "build",
-    buildStart() {
-      (0, import_store.addEntry)({
-        id: VIRTUAL_CEDAR_API,
-        route: "/**"
-      });
+    config: {
+      order: "pre",
+      handler() {
+        if (entriesInjected) {
+          return;
+        }
+        entriesInjected = true;
+        for (const route of routes) {
+          (0, import_store.addEntry)(toEntryMeta(route));
+        }
+      }
     },
     resolveId(id) {
-      if (id === import_store.catchAllEntry) {
-        return RESOLVED_VIRTUAL_CEDAR_API;
+      if (id.startsWith(RESOLVED_CEDAR_FN_PREFIX)) {
+        return id;
       }
-      if (id === VIRTUAL_CEDAR_API) {
-        return RESOLVED_VIRTUAL_CEDAR_API;
+      if (id.startsWith(VIRTUAL_CEDAR_FN_PREFIX)) {
+        return "\0" + id;
       }
       return void 0;
     },
     load(id) {
-      if (id !== RESOLVED_VIRTUAL_CEDAR_API) {
-        return void 0;
+      if (id.startsWith(RESOLVED_CEDAR_FN_PREFIX)) {
+        const routeId = id.slice(RESOLVED_CEDAR_FN_PREFIX.length);
+        const route = routes.find((r) => r.id === routeId);
+        if (!route) {
+          return void 0;
+        }
+        if (route.type === "graphql") {
+          return generateGraphQLModule(route.entry);
+        }
+        return generateFunctionModule(route.entry);
       }
-      const apiRootPathArg = apiRootPath !== void 0 ? `{ apiRootPath: ${JSON.stringify(apiRootPath)} }` : "undefined";
-      return `
-import { buildCedarDispatcher } from '@cedarjs/api-server/udDispatcher';
-const { fetchable } = await buildCedarDispatcher(${apiRootPathArg});
-export default fetchable;
-`;
+      return void 0;
     }
   };
 }
+function generateGraphQLModule(distPath) {
+  return `
+    import { createGraphQLHandler } from '@cedarjs/vite/ud-handlers/graphql';
+    export default createGraphQLHandler({ distPath: ${JSON.stringify(distPath)} });
+  `;
+}
+function generateFunctionModule(distPath) {
+  return `
+    import { createFunctionHandler } from '@cedarjs/vite/ud-handlers/function';
+    export default createFunctionHandler({ distPath: ${JSON.stringify(distPath)} });
+  `;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   cedarUniversalDeployPlugin

package/dist/cjs/plugins/vite-plugin-cedar-wait-for-api-server.js

@@ -39,6 +39,7 @@ function cedarWaitForApiServer() {
   const cedarConfig = (0, import_project_config.getConfig)();
   const apiPort = cedarConfig.api.port;
   const apiHost = cedarConfig.api.host || "localhost";
+  const isUnifiedDev = process.env.__CEDAR_UNIFIED_DEV === "true";
   return {
     name: "cedar-wait-for-api-server",
     apply: "serve",
@@ -51,7 +52,7 @@ function cedarWaitForApiServer() {
         // don't use startsWith here
         url === apiGqlUrl || // The two checks below are for when we support GraphQL-over-HTTP
         url.startsWith(apiGqlUrl + "/") || url.startsWith(apiGqlUrl + "?"));
-        if (!isApiRequest || serverHasBeenUp) {
+        if (!isApiRequest || serverHasBeenUp || isUnifiedDev) {
           return next();
         }
         try {