@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/commands/serve.js

@@ -1,15 +1,53 @@
 import fs from "node:fs";
-import path from "path";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { serve as serveSrvx } from "srvx";
 import { terminalLink } from "termi-link";
 import * as apiServerCLIConfig from "@cedarjs/api-server/apiCliConfig";
 import * as bothServerCLIConfig from "@cedarjs/api-server/bothCliConfig";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
-import { projectIsEsm } from "@cedarjs/project-config";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import * as webServerCLIConfig from "@cedarjs/web-server";
-import c from "../lib/colors.js";
 import { getPaths, getConfig } from "../lib/index.js";
 import { serverFileExists } from "../lib/project.js";
 import { webSsrServerHandler } from "./serveWebHandler.js";
+function refuseServerFileUnderUD() {
+  console.error(
+    c.error(
+      "\n api/src/server.ts was detected, but a custom server file is not supported with --ud. It is a Fastify concept \u2014 anything registered there (Realtime, custom plugins, custom middleware) would silently be skipped if serving continued.\n"
+    )
+  );
+  process.exit(1);
+}
+function resolveUDEntryPath() {
+  const base = path.join(getPaths().api.dist, "ud", "index");
+  for (const ext of [".mjs", ".js"]) {
+    const entryPath = base + ext;
+    if (fs.existsSync(entryPath)) {
+      return entryPath;
+    }
+  }
+  return null;
+}
+async function startUDServer(entryPath, host, port) {
+  const mod = await import(pathToFileURL(entryPath).href);
+  const fetchable = mod.default ?? mod;
+  if (!fetchable || typeof fetchable.fetch !== "function") {
+    throw new Error(
+      `UD entry at ${entryPath} does not export a Fetchable (\`export default { fetch }\`).`
+    );
+  }
+  const server = serveSrvx({
+    ...fetchable,
+    port,
+    hostname: host,
+    gracefulShutdown: false,
+    manual: true
+  });
+  server.serve();
+  await server.ready();
+  return server;
+}
 const command = "serve [side]";
 const description = "Start a server for serving both the api and web sides";
 const builder = async (yargs) => {
@@ -18,7 +56,14 @@ const builder = async (yargs) => {
   yargs.command({
     command: "$0",
     description: bothServerCLIConfig.description,
-    builder: bothServerCLIConfig.builder,
+    builder: (yargs2) => {
+      bothServerCLIConfig.builder(yargs2);
+      return yargs2.option("ud", {
+        description: "Use the Universal Deploy server for the API side. The web side is served by the existing static file server. Pass --ud to opt in; the default is Fastify for both sides.",
+        type: "boolean",
+        default: false
+      });
+    },
     handler: async (argv) => {
       recordTelemetryAttributes({
         command: "serve",
@@ -26,25 +71,129 @@ const builder = async (yargs) => {
         host: argv.host,
         socket: argv.socket
       });
+      if (argv.ud) {
+        if (argv.port) {
+          console.error(
+            c.error(
+              "\n The --port flag is not supported with --ud. Use --web-port and --api-port instead.\n"
+            )
+          );
+          process.exit(1);
+        }
+        const udEntryPath = resolveUDEntryPath();
+        if (!udEntryPath) {
+          console.error(
+            c.error(
+              "\n Universal Deploy server entry not found.  Please run `yarn cedar build --ud` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+        const webDistIndexHtml = path.join(getPaths().web.dist, "index.html");
+        if (!fs.existsSync(webDistIndexHtml)) {
+          console.error(
+            c.error(
+              "\n Web build artifacts not found.\n Please run `yarn cedar build` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+        if (serverFileExists()) {
+          refuseServerFileUnderUD();
+        }
+        const { getAPIHost, getAPIPort, getWebHost, getWebPort } = await import("@cedarjs/api-server/cliHelpers");
+        const apiPort = argv.apiPort ?? getAPIPort();
+        const apiHost = argv.apiHost ?? getAPIHost();
+        const webPort = argv.webPort ?? getWebPort({ isPublicSide: true });
+        const webHost = argv.webHost ?? getWebHost({ isPublicSide: true });
+        const apiRootPath = argv.apiRootPath ?? "/";
+        const apiTarget = `http://${apiHost.includes(":") ? `[${apiHost}]` : apiHost}:${apiPort}`;
+        const { staticMiddleware } = await import("srvx/static");
+        const apiUrl = getConfig().web.apiUrl;
+        const webDist = getPaths().web.dist;
+        const prerenderIndexPath = path.join(webDist, "200.html");
+        const fallbackIndexPath = fs.existsSync(prerenderIndexPath) ? prerenderIndexPath : path.join(webDist, "index.html");
+        const spaHtml = fs.readFileSync(fallbackIndexPath, "utf-8");
+        const webServer = serveSrvx({
+          // Dummy fetch handler. All requests are handled by middleware
+          fetch: async () => new Response("Not Found", { status: 404 }),
+          middleware: [
+            staticMiddleware({ dir: webDist }),
+            async (req, next) => {
+              const url = new URL(req.url, "http://localhost");
+              if (!url.pathname.startsWith(apiUrl)) {
+                return next();
+              }
+              const targetPath = url.pathname.slice(apiUrl.length) || "/";
+              const root = apiRootPath === "/" ? "" : apiRootPath;
+              const targetUrl = `${apiTarget}${root}${targetPath}${url.search}`;
+              const forwardedHeaders = new Headers(req.headers);
+              if (!forwardedHeaders.has("x-forwarded-host")) {
+                forwardedHeaders.set(
+                  "x-forwarded-host",
+                  req.headers.get("host") || url.host
+                );
+              }
+              if (!forwardedHeaders.has("x-forwarded-proto")) {
+                forwardedHeaders.set("x-forwarded-proto", "http");
+              }
+              return fetch(targetUrl, {
+                method: req.method,
+                headers: forwardedHeaders,
+                body: req.body,
+                // @ts-expect-error - `duplex` is required when forwarding a
+                // request body via fetch (Node 18+).
+                duplex: "half"
+              });
+            },
+            () => {
+              const headers = { "Content-Type": "text/html" };
+              return new Response(spaHtml, { headers });
+            }
+          ],
+          port: webPort,
+          hostname: webHost,
+          gracefulShutdown: false,
+          manual: true
+        });
+        webServer.serve();
+        await webServer.ready();
+        console.log(`Web server listening at http://${webHost}:${webPort}`);
+        process.stdout.write(
+          `API server starting at http://${apiHost}:${apiPort}...`
+        );
+        await startUDServer(udEntryPath, apiHost, apiPort);
+        process.stdout.write(
+          `\rAPI server listening at http://${apiHost}:${apiPort}
+`
+        );
+        return;
+      }
       if (serverFileExists()) {
-        const { bothServerFileHandler } = await import("./serveBothHandler.js");
-        await bothServerFileHandler(argv);
+        const serveBothHandlers = await import("./serveBothHandler.js");
+        await serveBothHandlers.bothServerFileHandler(argv);
       } else if (rscEnabled || streamingEnabled) {
-        const { bothSsrRscServerHandler } = await import("./serveBothHandler.js");
-        await bothSsrRscServerHandler(argv, rscEnabled);
+        const serveBothHandlers = await import("./serveBothHandler.js");
+        await serveBothHandlers.bothSsrRscServerHandler(argv, rscEnabled);
       } else {
-        if (!projectIsEsm()) {
-          const { handler } = await import("@cedarjs/api-server/cjs/bothCliConfigHandler");
-          await handler(argv);
-        } else {
-          await bothServerCLIConfig.handler(argv);
-        }
+        await bothServerCLIConfig.handler(argv);
       }
     }
   }).command({
     command: "api",
     description: apiServerCLIConfig.description,
-    builder: apiServerCLIConfig.builder,
+    builder: (yargs2) => {
+      if (typeof apiServerCLIConfig.builder === "function") {
+        apiServerCLIConfig.builder(yargs2);
+      }
+      return yargs2.option("ud", {
+        // UD serving is opt-in. Pass --ud to use the new srvx server instead
+        // of the legacy Fastify server.
+        description: "Use the Universal Deploy server. Pass --ud to opt in; the default is Fastify.",
+        type: "boolean",
+        default: false
+      });
+    },
     handler: async (argv) => {
       recordTelemetryAttributes({
         command: "serve",
@@ -53,16 +202,39 @@ const builder = async (yargs) => {
         socket: argv.socket,
         apiRootPath: argv.apiRootPath
       });
+      const { getAPIHost, getAPIPort } = await import("@cedarjs/api-server/cliHelpers");
+      const apiPort = argv.port ?? getAPIPort({ isPublicSide: true });
+      const apiHost = argv.host ?? getAPIHost({ isPublicSide: true });
+      argv.port = apiPort;
+      argv.host = apiHost;
+      if (argv.ud) {
+        if (serverFileExists()) {
+          refuseServerFileUnderUD();
+        }
+        const udEntryPath = resolveUDEntryPath();
+        if (!udEntryPath) {
+          console.error(
+            c.error(
+              "\n Universal Deploy server entry not found.  Please run `yarn cedar build --ud` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+        process.stdout.write(
+          `API server starting at http://${apiHost}:${apiPort}...`
+        );
+        await startUDServer(udEntryPath, apiHost, apiPort);
+        process.stdout.write(
+          `\rAPI server listening at http://${apiHost}:${apiPort}
+`
+        );
+        return;
+      }
       if (serverFileExists()) {
         const { apiServerFileHandler } = await import("./serveApiHandler.js");
         await apiServerFileHandler(argv);
       } else {
-        if (!projectIsEsm()) {
-          const { handler } = await import("@cedarjs/api-server/cjs/apiCliConfigHandler");
-          await handler(argv);
-        } else {
-          await apiServerCLIConfig.handler(argv);
-        }
+        await apiServerCLIConfig.handler(argv);
       }
     }
   }).command({
@@ -88,7 +260,7 @@ const builder = async (yargs) => {
       command: "serve"
     });
     const positionalArgs = argv._;
-    if (positionalArgs.includes("web") && !fs.existsSync(path.join(getPaths().web.dist), "index.html")) {
+    if (positionalArgs.includes("web") && !webSideIsBuilt(streamingEnabled || rscEnabled)) {
       console.error(
         c.error(
           "\n Please run `yarn cedar build web` before trying to serve web. \n"
@@ -114,23 +286,56 @@ const builder = async (yargs) => {
         );
         process.exit(1);
       }
+      if (argv.ud) {
+        const udEntryPath = resolveUDEntryPath();
+        if (!udEntryPath) {
+          console.error(
+            c.error(
+              "\n Universal Deploy server entry not found.  Please run `yarn cedar build --ud` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+      }
     }
     if (positionalArgs.length === 1) {
       if (!apiSideExists && !rscEnabled) {
         console.error(
           c.error(
-            "\n Unable to serve the both sides as no `api` folder exists. Please use `yarn cedar serve web` instead. \n"
+            "\nUnable to serve web and api as no `api` folder exists. Please use `yarn cedar serve web` instead. \n"
           )
         );
         process.exit(1);
       }
-      if (fs.existsSync(path.join(getPaths().api.base)) && !fs.existsSync(path.join(getPaths().api.dist)) || !fs.existsSync(path.join(getPaths().web.dist), "index.html")) {
-        console.error(
-          c.error(
-            "\n Please run `yarn cedar build` before trying to serve your redwood app. \n"
-          )
-        );
-        process.exit(1);
+      if (argv.ud) {
+        const udEntryPath = resolveUDEntryPath();
+        if (!udEntryPath) {
+          console.error(
+            c.error(
+              "\n Universal Deploy server entry not found.  Please run `yarn cedar build --ud` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+        const webDistIndexHtml = path.join(getPaths().web.dist, "index.html");
+        if (!fs.existsSync(webDistIndexHtml)) {
+          console.error(
+            c.error(
+              "\n Web build artifacts not found.\n Please run `yarn cedar build` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+      } else {
+        const apiExistsButIsNotBuilt = apiSideExists && !fs.existsSync(getPaths().api.dist);
+        if (apiExistsButIsNotBuilt || !webSideIsBuilt(streamingEnabled || rscEnabled)) {
+          console.error(
+            c.error(
+              "\nPlease run `yarn cedar build` before trying to serve your Cedar app.\n"
+            )
+          );
+          process.exit(1);
+        }
       }
     }
     if (!process.env.NODE_ENV) {
@@ -143,6 +348,15 @@ const builder = async (yargs) => {
     )}`
   );
 };
+function webSideIsBuilt(isStreamingOrRSC) {
+  if (isStreamingOrRSC) {
+    return fs.existsSync(
+      path.join(getPaths().web.distBrowser, "client-build-manifest.json")
+    );
+  } else {
+    return fs.existsSync(path.join(getPaths().web.dist, "index.html"));
+  }
+}
 export {
   builder,
   command,

package/dist/commands/serveApiHandler.js

@@ -1,15 +1,16 @@
-import execa from "execa";
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
 import { getPaths } from "@cedarjs/project-config";
-const apiServerFileHandler = async (argv) => {
-  const args = ["node", "server.js", "--apiRootPath", argv.apiRootPath];
+async function apiServerFileHandler(argv) {
+  const args = ["server.js", "--apiRootPath", argv.apiRootPath ?? "/"];
   if (argv.port) {
-    args.push("--apiPort", argv.port);
+    args.push("--apiPort", String(argv.port));
   }
-  await execa("yarn", args, {
+  const filteredArgs = args.filter((arg) => Boolean(arg));
+  await runBin("node", filteredArgs, {
     cwd: getPaths().api.dist,
     stdio: "inherit"
   });
-};
+}
 export {
   apiServerFileHandler
 };

package/dist/commands/serveBothHandler.js

@@ -1,46 +1,53 @@
 import path from "path";
 import concurrently from "concurrently";
-import execa from "execa";
-import { handler as apiServerHandler } from "@cedarjs/api-server/cjs/apiCliConfigHandler";
+import { handler as apiServerHandler } from "@cedarjs/api-server/apiCliConfigHandler";
 import {
   getAPIHost,
   getAPIPort,
+  getAPIRootPath,
   getWebHost,
   getWebPort
-} from "@cedarjs/api-server/cjs/cliHelpers";
+} from "@cedarjs/api-server/cliHelpers";
+import { formatRunBinCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
 import { getConfig, getPaths } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { exitWithError } from "../lib/exit.js";
+const hasStringMessage = (error) => {
+  const message = typeof error === "object" && error !== null ? Reflect.get(error, "message") : void 0;
+  return typeof error === "object" && error !== null && "message" in error && typeof message === "string";
+};
 const bothServerFileHandler = async (argv) => {
   if (getConfig().experimental?.rsc?.enabled || getConfig().experimental?.streamingSsr?.enabled) {
     logSkippingFastifyWebServer();
-    await execa("yarn", ["rw-serve-fe"], {
+    await runBin("cedar-serve-fe", [], {
       cwd: getPaths().web.base,
       stdio: "inherit"
     });
   } else {
     argv.apiPort ??= getAPIPort();
     argv.apiHost ??= getAPIHost();
-    argv.webPort ??= getWebPort();
-    argv.webHost ??= getWebHost();
+    argv.webPort ??= getWebPort({ isPublicSide: true });
+    argv.webHost ??= getWebHost({ isPublicSide: true });
+    const apiRootPath = argv.apiRootPath ?? getAPIRootPath();
     const apiProxyTarget = [
       "http://",
       argv.apiHost.includes(":") ? `[${argv.apiHost}]` : argv.apiHost,
       ":",
       argv.apiPort,
-      argv.apiRootPath
+      apiRootPath
     ].join("");
     const { result } = concurrently(
       [
         {
           name: "api",
-          command: `yarn node ${path.join("dist", "server.js")} --apiPort ${argv.apiPort} --apiHost ${argv.apiHost} --apiRootPath ${argv.apiRootPath}`,
+          command: `${formatRunBinCommand("node", [path.join("dist", "server.js"), "--apiPort", String(argv.apiPort), "--apiHost", argv.apiHost, "--apiRootPath", apiRootPath])}`,
           cwd: getPaths().api.base,
           prefixColor: "cyan"
         },
         {
           name: "web",
-          command: `yarn rw-web-server --port ${argv.webPort} --host ${argv.webHost} --api-proxy-target ${apiProxyTarget}`,
+          command: `${formatRunBinCommand("cedar-web-server", ["--port", String(argv.webPort), "--host", argv.webHost, "--api-proxy-target", apiProxyTarget])}`,
           cwd: getPaths().base,
           prefixColor: "blue"
         }
@@ -54,10 +61,11 @@ const bothServerFileHandler = async (argv) => {
     try {
       await result;
     } catch (error) {
-      if (typeof error?.message !== "undefined") {
+      const message = hasStringMessage(error) ? error.message : void 0;
+      if (typeof message !== "undefined") {
         errorTelemetry(
           process.argv,
-          `Error concurrently starting sides: ${error.message}`
+          `Error concurrently starting sides: ${message}`
         );
         exitWithError(error);
       }
@@ -66,14 +74,15 @@ const bothServerFileHandler = async (argv) => {
 };
 const bothSsrRscServerHandler = async (argv, rscEnabled) => {
   const apiPromise = apiServerHandler({
-    apiRootPath: argv.apiRootPath,
+    apiRootPath: argv.apiRootPath ?? getAPIRootPath(),
     host: argv.apiHost,
     port: argv.apiPort
   });
-  const fePromise = execa("yarn", ["rw-serve-fe"], {
+  const fePromise = runBin("cedar-serve-fe", [], {
     cwd: getPaths().web.base,
     stdio: "inherit",
     env: rscEnabled ? {
+      ...process.env,
       // TODO (RSC): Is this how we want to do it? If so, we need to find a way
       // to merge this with users' NODE_OPTIONS
       NODE_OPTIONS: "--conditions react-server"

package/dist/commands/serveWebHandler.js

@@ -1,10 +1,11 @@
-import execa from "execa";
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
 import { getPaths } from "@cedarjs/project-config";
 const webSsrServerHandler = async (rscEnabled) => {
-  await execa("yarn", ["rw-serve-fe"], {
+  await runBin("cedar-serve-fe", [], {
     cwd: getPaths().web.base,
     stdio: "inherit",
     env: rscEnabled ? {
+      ...process.env,
       // TODO (RSC): Is this how we want to do it? If so, we need to find a way
       // to merge this with users' NODE_OPTIONS
       NODE_OPTIONS: "--conditions react-server"

package/dist/commands/setup/auth/auth.js

@@ -1,11 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import execa from "execa";
 import { terminalLink } from "termi-link";
-import {
-  recordTelemetryAttributes,
-  standardAuthBuilder
-} from "@cedarjs/cli-helpers";
+import { standardAuthBuilder } from "@cedarjs/cli-helpers/auth/setupHelpers";
+import { addRootPackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getPaths } from "../../../lib/index.js";
 const command = "auth <provider>";
 const description = "Set up an auth configuration";
@@ -198,7 +196,7 @@ async function getAuthSetupHandler(module) {
     } else {
       customRequire = require;
     }
-  } catch (error) {
+  } catch {
     customRequire = require;
   }
   const packageJsonPath = customRequire.resolve("@cedarjs/cli/package.json");
@@ -216,22 +214,28 @@ async function getAuthSetupHandler(module) {
       if (packument.error) {
         throw new Error(packument.error);
       }
-    } catch (error) {
+    } catch (e) {
       throw new Error(
-        `Couldn't fetch packument for ${module}: ${error.message}`
+        `Couldn't fetch packument for ${module}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    if (!packument.versions || typeof packument.versions !== "object" || Array.isArray(packument.versions)) {
+      throw new Error(
+        `Couldn't fetch packument for ${module}: invalid versions field`
       );
     }
     const versionIsPublished = Object.keys(packument.versions).includes(version);
     if (!versionIsPublished) {
       version = "canary";
     }
-    await execa.command(`yarn add -D ${module}@${version}`, {
+    await addRootPackages([`${module}@${version}`], {
+      dev: true,
       stdio: "inherit",
       cwd: getPaths().base
     });
   }
   const setupModule = await import(module);
-  return setupModule.default.handler;
+  return setupModule.handler;
 }
 function isInstalled(module) {
   const { dependencies, devDependencies } = JSON.parse(
@@ -254,7 +258,7 @@ function isInstalled(module) {
     return possiblePaths.some((modulePath) => {
       return fs.existsSync(path.join(modulePath, "package.json"));
     });
-  } catch (error) {
+  } catch {
     return false;
   }
 }

package/dist/commands/setup/cache/cache.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "cache <client>";
 const description = "Sets up an init file for service caching";
 const builder = (yargs) => {

package/dist/commands/setup/cache/cacheHandler.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "path";
 import { Listr } from "listr2";
-import { addEnvVarTask } from "@cedarjs/cli-helpers";
+import { terminalLink } from "termi-link";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { addEnvVarTask } from "@cedarjs/cli-helpers/project";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import c from "../../../lib/colors.js";
 import { addPackagesTask, getPaths, writeFile } from "../../../lib/index.js";
 import { isTypeScriptProject } from "../../../lib/project.js";
 const CLIENT_PACKAGE_MAP = {
@@ -14,15 +15,18 @@ const CLIENT_HOST_MAP = {
   memcached: "localhost:11211",
   redis: "redis://localhost:6379"
 };
-const handler = async ({ client, force }) => {
-  const extension = isTypeScriptProject ? "ts" : "js";
+const handler = async ({
+  client,
+  force
+}) => {
+  const extension = isTypeScriptProject() ? "ts" : "js";
   const tasks = new Listr([
     await addPackagesTask({
       packages: [CLIENT_PACKAGE_MAP[client]],
       side: "api"
     }),
     {
-      title: `Writing api/src/lib/cache.js`,
+      title: `Writing api/src/lib/cache.${extension}`,
       task: () => {
         const template = fs.readFileSync(
           path.join(
@@ -51,7 +55,7 @@ const handler = async ({ client, force }) => {
         task.title = `One more thing...
 
           ${c.tip("Check out the Service Cache docs for config and usage:")}
-          ${c.link("https://cedarjs.com/docs/services#caching")}
+          ${terminalLink("", "https://cedarjs.com/docs/services#caching")}
         `;
       }
     }
@@ -59,9 +63,11 @@ const handler = async ({ client, force }) => {
   try {
     await tasks.run();
   } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    process.exit(exitCode);
   }
 };
 export {

package/dist/commands/setup/database/database.js

@@ -0,0 +1,15 @@
+import { terminalLink } from "termi-link";
+import * as setupDatabasePostgres from "./postgres.js";
+const command = "database <command>";
+const description = "Switch your project's database";
+const builder = (yargs) => yargs.command(setupDatabasePostgres).demandCommand().epilogue(
+  `Also see the ${terminalLink(
+    "CedarJS CLI Reference",
+    "https://cedarjs.com/docs/cli-commands#setup"
+  )}`
+);
+export {
+  builder,
+  command,
+  description
+};

package/dist/commands/setup/database/postgres.js

@@ -0,0 +1,19 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+const command = "postgres";
+const description = "Switch your project from SQLite to PostgreSQL (schema, dependencies, and database adapter)";
+function builder(yargs) {
+  return yargs;
+}
+async function handler() {
+  recordTelemetryAttributes({
+    command: "setup database postgres"
+  });
+  const { handler: handler2 } = await import("./postgresHandler.js");
+  return handler2();
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};