@cedarjs/cli 7.0.0 → 8.0.0-canary.3265

package/dist/commands/setup/uploads/uploadsHandler.js

@@ -1,93 +1,265 @@
 import fs from "node:fs";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { Listr } from "listr2";
 import { format } from "prettier";
 import { terminalLink } from "termi-link";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { getPrettierOptions } from "@cedarjs/cli-helpers/fileHelpers";
 import {
   addApiPackages,
-  getPrettierOptions,
-  colors as c
-} from "@cedarjs/cli-helpers";
+  addWebPackages
+} from "@cedarjs/cli-helpers/installHelpers";
 import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { addEnvVar } from "@cedarjs/cli-helpers/project";
+import { getSchemaPath } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
 import { isTypeScriptProject } from "../../../lib/project.js";
-import { runTransform } from "../../../lib/runTransform.js";
-const handler = async ({ force }) => {
+import { generateSecret } from "../../generate/secret/secret.js";
+import { setupServerFileTasks } from "../server-file/serverFileHandler.js";
+import { addUploadModel } from "./schemaPrisma.js";
+import {
+  addUploadsPlugin,
+  detectServerAuth,
+  hasUploadsPlugin
+} from "./serverFile.js";
+const UPPY_VERSION = "^6.0.0";
+const S3_IMPORTS = `import { S3Client } from '@aws-sdk/client-s3'
+
+import { createS3Provider } from '@cedarjs/uploads/s3'
+`;
+const S3_CLIENT = `
+// Your own S3 client. It stays available for S3-specific work (lifecycle
+// rules, CORS, and so on) alongside the storage target below. Credentials
+// come from the SDK's default chain: AWS_ACCESS_KEY_ID and
+// AWS_SECRET_ACCESS_KEY in .env, or an IAM role, SSO, or container
+// credentials in production. For an S3-compatible service, add \`endpoint\`
+// and \`forcePathStyle: true\`.
+export const s3Client = new S3Client({
+  region: process.env.AWS_REGION,
+})
+`;
+const TARGET_BLOCKS = {
+  fs: `  // Files uploaded through the api server and stored on local disk. Good for
+  // development and single-server deploys.
+  local: createFsProvider({
+    uploadDir: path.join(getPaths().api.base, '.uploads'),
+    serveBaseUrl: process.env.UPLOAD_SERVE_BASE_URL,
+    signSecret: process.env.UPLOAD_TOKEN_SECRET,
+  }),
+`,
+  db: `  // Small files stored inline in the Upload row (avatars, thumbnails).
+  thumbnails: createDbProvider(),
+`,
+  s3: `  // Files uploaded straight from the browser to S3 with presigned URLs.
+  files: createS3Provider({
+    client: s3Client,
+    bucket: process.env.S3_BUCKET_UPLOADS,
+    region: process.env.AWS_REGION,
+    keyPrefix: 'uploads/',
+  }),
+`
+};
+const PROFILE_BLOCKS = {
+  fs: `  attachment: {
+    target: 'local',
+    allowedMimeTypes: ['application/pdf', 'image/png', 'image/jpeg'],
+    maxFileSize: 25 * 1024 * 1024,
+    maxFiles: 10,
+  },
+`,
+  db: `  avatar: {
+    target: 'thumbnails',
+    allowedMimeTypes: ['image/png', 'image/jpeg'],
+    maxFileSize: DB_MAX_FILE_SIZE,
+    maxFiles: 1,
+  },
+`,
+  s3: `  document: {
+    target: 'files',
+    allowedMimeTypes: ['application/pdf', 'image/*'],
+    maxFileSize: 100 * 1024 * 1024,
+    maxFiles: 5,
+  },
+`
+};
+const handler = async ({ targets, force }) => {
+  const paths = getPaths();
   const projectIsTypescript = isTypeScriptProject();
-  const packageJson = await import(path.join(getPaths().base, "package.json"), {
-    with: { type: "json" }
-  });
+  const ext = projectIsTypescript ? "ts" : "js";
+  const wantsFs = targets.includes("fs");
+  const wantsDb = targets.includes("db");
+  const wantsS3 = targets.includes("s3");
+  const wantsUppy = wantsFs || wantsS3;
+  const packageJson = await import(pathToFileURL(path.join(paths.base, "package.json")).href, { with: { type: "json" } });
   const cedarVersion = packageJson.default.devDependencies["@cedarjs/core"] ?? "latest";
+  const serverFilePath = path.join(paths.api.src, `server.${ext}`);
+  const writeTemplateFile = async (templateFile, outputPath, replacements = {}) => {
+    const templatePath = path.resolve(
+      import.meta.dirname,
+      "templates",
+      templateFile
+    );
+    let templateContent = fs.readFileSync(templatePath, "utf-8");
+    for (const [token, value] of Object.entries(replacements)) {
+      templateContent = templateContent.replaceAll(token, value);
+    }
+    const content = projectIsTypescript ? templateContent : await transformTSToJS(outputPath, templateContent);
+    return writeFile(outputPath, content, { overwriteExisting: force });
+  };
+  const apiPackages = [`@cedarjs/uploads@${cedarVersion}`];
+  const webPackages = [`@cedarjs/uploads@${cedarVersion}`];
+  if (wantsS3) {
+    apiPackages.push("@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner");
+  }
+  if (wantsUppy) {
+    webPackages.push(
+      `@uppy/core@${UPPY_VERSION}`,
+      `@uppy/react@${UPPY_VERSION}`,
+      `@uppy/dashboard@${UPPY_VERSION}`
+    );
+  }
+  if (wantsFs) {
+    webPackages.push(`@uppy/xhr-upload@${UPPY_VERSION}`);
+  }
+  if (wantsS3) {
+    webPackages.push(`@uppy/aws-s3@${UPPY_VERSION}`);
+  }
   const tasks = new Listr(
     [
       {
-        title: `Adding api/src/lib/uploads.${projectIsTypescript ? "ts" : "js"}...`,
+        ...addApiPackages(apiPackages),
+        title: "Adding @cedarjs/uploads to your api side..."
+      },
+      {
+        ...addWebPackages(webPackages),
+        title: "Adding @cedarjs/uploads to your web side..."
+      },
+      {
+        title: "Adding the Upload model to schema.prisma...",
         task: async () => {
-          const templatePath = path.resolve(
-            import.meta.dirname,
-            "templates",
-            "srcLibUploads.ts.template"
-          );
-          const templateContent = fs.readFileSync(templatePath, {
-            encoding: "utf8",
-            flag: "r"
-          });
-          const uploadsPath = path.join(
-            getPaths().api.lib,
-            `uploads.${projectIsTypescript ? "ts" : "js"}`
+          const schemaPath = await getSchemaPath(paths.api.prismaConfig);
+          const schema = fs.readFileSync(schemaPath, "utf-8");
+          fs.writeFileSync(schemaPath, addUploadModel(schema));
+        }
+      },
+      {
+        title: `Adding api/src/lib/uploads.${ext}...`,
+        task: async () => {
+          await writeTemplateFile(
+            "srcLibUploads.ts.template",
+            path.join(paths.api.lib, `uploads.${ext}`),
+            {
+              __S3_IMPORTS__: wantsS3 ? S3_IMPORTS : "",
+              __S3_CLIENT__: wantsS3 ? S3_CLIENT : "",
+              __FS_IMPORT__: wantsFs ? "createFsProvider," : "",
+              __DB_IMPORT__: wantsDb ? "createDbProvider," : "",
+              __DB_MAX_IMPORT__: wantsDb ? "DB_MAX_FILE_SIZE," : "",
+              __PATH_IMPORT__: wantsFs ? "import path from 'node:path'\n\n" : "",
+              __GET_PATHS_IMPORT__: wantsFs ? "import { getPaths } from '@cedarjs/project-config'\n" : "",
+              __TARGETS__: targets.map((t) => TARGET_BLOCKS[t]).join("\n"),
+              __PROFILES__: targets.map((t) => PROFILE_BLOCKS[t]).join("\n")
+            }
           );
-          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
-          return writeFile(uploadsPath, uploadsContent, {
-            overwriteExisting: force
-          });
         }
       },
       {
-        title: `Adding signedUrl function...`,
+        title: "Adding the uploads SDL and service...",
         task: async () => {
-          const templatePath = path.resolve(
-            import.meta.dirname,
-            "templates",
-            "signedUrl.ts.template"
+          await writeTemplateFile(
+            "uploads.sdl.ts.template",
+            path.join(paths.api.graphql, `uploads.sdl.${ext}`)
           );
-          const templateContent = fs.readFileSync(templatePath, {
-            encoding: "utf8",
-            flag: "r"
-          });
-          const uploadsPath = path.join(
-            getPaths().api.functions,
-            `signedUrl.${projectIsTypescript ? "ts" : "js"}`
+          await writeTemplateFile(
+            "uploads.ts.template",
+            path.join(paths.api.services, "uploads", `uploads.${ext}`)
           );
-          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
-          return writeFile(uploadsPath, uploadsContent, {
-            overwriteExisting: force
-          });
         }
       },
       {
-        ...addApiPackages([`@cedarjs/storage@${cedarVersion}`]),
-        title: "Adding dependencies to your api side..."
+        title: "Adding the upload directives...",
+        task: async () => {
+          const directives = ["requireUploadToken", "withSignedUrl"];
+          if (wantsDb) {
+            directives.push("withDataUri");
+          }
+          for (const name of directives) {
+            await writeTemplateFile(
+              `${name}.ts.template`,
+              path.join(paths.api.directives, name, `${name}.${ext}`)
+            );
+          }
+        }
       },
       {
-        title: "Modifying api/src/lib/db to add uploads prisma extension..",
-        task: async () => {
-          const dbPath = path.join(
-            getPaths().api.lib,
-            `db.${projectIsTypescript ? "ts" : "js"}`
-          );
-          const transformResult = await runTransform({
-            transformPath: path.join(import.meta.dirname, "dbCodemod.js"),
-            targetPaths: [dbPath]
-          });
-          if (transformResult.error) {
-            if (transformResult.error === "RW_CODEMOD_ERR_OLD_FORMAT") {
-              throw new Error(
-                "It looks like your src/lib/db file is using the old format. Please update it as per the v8 upgrade guide: https://cedarjs.com/docs/8.x/upgrade-guides/v8#database-file-structure-change. And run again. \n\nYou can also manually modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
-              );
-            }
+        title: "Adding the server file...",
+        task: (_ctx, task) => task.newListr(setupServerFileTasks({ force: false })),
+        skip: () => fs.existsSync(serverFilePath) ? "api/src/server already exists; skipping." : false
+      },
+      {
+        title: "Registering the upload plugin in api/src/server...",
+        task: async (_ctx, task) => {
+          const source = fs.readFileSync(serverFilePath, "utf-8");
+          if (hasUploadsPlugin(source)) {
+            task.skip("The upload plugin is already registered; skipping.");
+            return;
+          }
+          const graphqlPath = path.join(paths.api.functions, `graphql.${ext}`);
+          const authPath = path.join(paths.api.lib, `auth.${ext}`);
+          const auth = fs.existsSync(graphqlPath) && fs.existsSync(authPath) && fs.readFileSync(authPath, "utf-8").includes("getCurrentUser") ? detectServerAuth(fs.readFileSync(graphqlPath, "utf-8")) : null;
+          let updated;
+          try {
+            updated = addUploadsPlugin(source, { auth });
+          } catch {
             throw new Error(
-              "Could not add the prisma extension. \n Please modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
+              `Could not find \`await server.start()\` in ${path.relative(
+                paths.base,
+                serverFilePath
+              )}. Register the plugin by hand before the server starts:
+
+  import { cedarUploadsPlugin } from '@cedarjs/uploads'
+  import { db } from 'src/lib/db'
+  import { targets } from 'src/lib/uploads'
+
+  await server.register(cedarUploadsPlugin, {
+    tokenSecret: process.env.UPLOAD_TOKEN_SECRET,
+    targets,
+    db,
+  })
+`
+            );
+          }
+          fs.writeFileSync(serverFilePath, updated);
+        }
+      },
+      {
+        title: "Adding environment variables to .env...",
+        task: () => {
+          addEnvVar(
+            "UPLOAD_TOKEN_SECRET",
+            generateSecret(),
+            "Signs upload tokens and file-serving URLs. Keep it secret and use a different value per environment."
+          );
+          if (wantsFs) {
+            addEnvVar(
+              "UPLOAD_SERVE_BASE_URL",
+              "http://localhost:8911",
+              "Origin the api server is reachable at, used to build signed URLs for locally stored files."
+            );
+          }
+          if (wantsS3) {
+            addEnvVar(
+              "AWS_REGION",
+              "us-east-1",
+              "Region of the uploads bucket."
+            );
+            addEnvVar("AWS_ACCESS_KEY_ID", "replace-me", "");
+            addEnvVar("AWS_SECRET_ACCESS_KEY", "replace-me", "");
+            addEnvVar(
+              "S3_BUCKET_UPLOADS",
+              "replace-me",
+              "Bucket direct uploads land in."
             );
           }
         }
@@ -96,10 +268,10 @@ const handler = async ({ force }) => {
         title: "Prettifying changed files",
         task: async (_ctx, task) => {
           const prettifyPaths = [
-            path.join(getPaths().api.lib, "db.js"),
-            path.join(getPaths().api.lib, "db.ts"),
-            path.join(getPaths().api.lib, "uploads.js"),
-            path.join(getPaths().api.lib, "uploads.ts")
+            serverFilePath,
+            path.join(paths.api.lib, `uploads.${ext}`),
+            path.join(paths.api.graphql, `uploads.sdl.${ext}`),
+            path.join(paths.api.services, "uploads", `uploads.${ext}`)
           ];
           for (const prettifyPath of prettifyPaths) {
             try {
@@ -108,11 +280,11 @@ const handler = async ({ force }) => {
               }
               const source = fs.readFileSync(prettifyPath, "utf-8");
               const prettierOptions = await getPrettierOptions();
-              const prettifiedApp = await format(source, {
+              const prettified = await format(source, {
                 ...prettierOptions,
                 parser: "babel-ts"
               });
-              fs.writeFileSync(prettifyPath, prettifiedApp, "utf-8");
+              fs.writeFileSync(prettifyPath, prettified, "utf-8");
             } catch {
               task.output = "Couldn't prettify the changes. Please reformat the files manually if needed.";
             }
@@ -122,15 +294,30 @@ const handler = async ({ force }) => {
       {
         title: "One more thing...",
         task: (_ctx, task) => {
+          const migrate = c.highlight(
+            formatCedarCommand(["prisma", "migrate", "dev"])
+          );
+          const types = c.highlight(formatCedarCommand(["generate", "types"]));
           task.title = `One more thing...
 
-          ${c.success("\nUploads and storage configured!\n")}
+          ${c.success("Uploads configured!")}
+
+          Next steps:
+
+            1. Apply the schema change: ${migrate}
+            2. Regenerate types: ${types}
+            3. Review the storage targets and upload profiles in api/src/lib/uploads.${ext}${wantsS3 ? "\n            4. Fill in the AWS_* and S3_BUCKET_UPLOADS values in .env" : ""}
 
-          Remember to add UPLOADS_SECRET to your .env file. You can generate one with ${c.highlight(formatCedarCommand(["generate", "secret"]))}
+          Upload tokens are bound to the logged-in user when the app has auth.
+          If you add auth later, pass
+          \`authenticate: createUploadAuthenticator({ authDecoder, getCurrentUser })\`
+          to the plugin in api/src/server.${ext}.
+
+          Schedule cleanupStaleUploads() from a recurring job to sweep uploads
+          that never completed.
 
           Check out the docs for more info:
           ${terminalLink("", "https://cedarjs.com/docs/uploads")}
-
         `;
         }
       }

package/dist/commands/setup.js

@@ -16,11 +16,12 @@ import * as setupNeon from "./setup/neon/neon.js";
 import * as setupPackage from "./setup/package/package.js";
 import * as setupRealtime from "./setup/realtime/realtime.js";
 import * as setupServerFile from "./setup/server-file/serverFile.js";
+import * as setupTenancy from "./setup/tenancy/tenancy.js";
 import * as setupUi from "./setup/ui/ui.js";
 import * as setupUploads from "./setup/uploads/uploads.js";
 const command = "setup <command>";
 const description = "Initialize project config and install packages";
-const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDatabase).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDatabase).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTenancy).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#setup"

package/dist/commands/studio.js

@@ -1,4 +1,4 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "studio";
 const description = "Run the CedarJS development studio";
 function builder(yargs) {

package/dist/commands/test/testHandler.js

@@ -1,13 +1,11 @@
-import fs from "node:fs";
-import path from "node:path";
-import execa from "execa";
-import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
 import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { ensurePosixPath } from "@cedarjs/project-config";
 import { errorTelemetry, timedTelemetry } from "@cedarjs/telemetry";
 import { getPaths } from "../../lib/index.js";
 import * as project from "../../lib/project.js";
 import { warnIfNonStandardDatasourceUrl } from "./datasourceWarning.js";
+import { assertSingleViteVersion } from "./viteVersionCheck.js";
 function hasStringMessage(value) {
   return typeof value === "object" && value !== null && "message" in value && value.message === "string";
 }
@@ -17,73 +15,29 @@ function getExitCode(value) {
   }
   return value.exitCode;
 }
-function isInGitRepository() {
-  try {
-    execa.commandSync("git rev-parse --is-inside-work-tree");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isInMercurialRepository() {
-  try {
-    execa.commandSync("hg --cwd . root");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isJestConfigFile(sides) {
-  for (const side of sides) {
-    try {
-      const jestConfigExists = fs.existsSync(path.join(side, "jest.config.js")) || fs.existsSync(path.join(side, "jest.config.ts"));
-      if (!jestConfigExists) {
-        console.error(
-          c.error(
-            `
-Error: Missing Jest config file ${side}/jest.config.js
-To add this file, run \`npx @cedarjs/codemods update-jest-config\`
-`
-          )
-        );
-        throw new Error(`Error: Jest config file not found in ${side} side`);
-      }
-    } catch (error) {
-      const message = hasStringMessage(error) ? error.message : `Error: Jest config file not found in ${side} side`;
-      errorTelemetry(process.argv, message);
-      process.exit(getExitCode(error) ?? 1);
-    }
-  }
-}
 const handler = async ({
   filter: filterParams = [],
-  watch = true,
-  collectCoverage = false,
   dbPush = true,
   force = false,
   ...others
 }) => {
   recordTelemetryAttributes({
     command: "test",
-    watch,
-    collectCoverage,
     dbPush
   });
+  let watch = true;
   const rwjsPaths = getPaths();
-  const forwardJestFlags = Object.keys(others).flatMap((flagName) => {
-    if ([
-      "collect-coverage",
-      "db-push",
-      "force",
-      "loadEnvFiles",
-      "watch",
-      "$0",
-      "_"
-    ].includes(flagName)) {
+  const forwardVitestFlags = Object.keys(others).flatMap((flagName) => {
+    if (["db-push", "force", "loadEnvFiles", "$0", "_"].includes(flagName)) {
       return [];
     }
     const flag = flagName.length > 1 ? `--${flagName}` : `-${flagName}`;
     const flagValue = others[flagName];
+    if (flagName === "watch") {
+      watch = flagValue === true;
+    } else if (flagName === "run" && flagValue) {
+      watch = false;
+    }
     if (Array.isArray(flagValue)) {
       return flagValue.flatMap((val) => [flag, val]);
     }
@@ -92,28 +46,25 @@ const handler = async ({
   const sides = filterParams.filter(
     (filterString) => project.workspaces().includes(filterString)
   );
-  const jestFilterArgs = [
+  const vitestFilterArgs = [
     ...filterParams.filter(
       (filterString) => !project.workspaces().includes(filterString)
     )
   ];
-  const jestArgs = [
-    ...jestFilterArgs,
-    ...forwardJestFlags,
-    collectCoverage ? "--collectCoverage" : null,
+  const vitestArgs = [
+    ...vitestFilterArgs,
+    ...forwardVitestFlags,
     "--passWithNoTests"
   ].filter((flagOrValue) => flagOrValue !== null);
-  if (watch && !process.env.CI && !collectCoverage) {
-    const hasSourceControl = isInGitRepository() || isInMercurialRepository();
-    jestArgs.push(hasSourceControl ? "--watch" : "--watchAll");
+  if (process.env.CI) {
+    vitestArgs.push("--run");
   }
-  if (!sides.length) {
-    project.workspaces().forEach((side) => sides.push(side));
-  }
-  if (sides.length > 0) {
-    jestArgs.push("--projects", ...sides);
+  if (!others["config"]) {
+    sides.forEach((side) => vitestArgs.push("--project", side));
+    if (!sides.length) {
+      project.workspaces().forEach((side) => sides.push(side));
+    }
   }
-  isJestConfigFile(sides);
   try {
     const cacheDirDb = `file:${ensurePosixPath(
       rwjsPaths.generated.base
@@ -126,8 +77,11 @@ const handler = async ({
     if (sides.includes("api")) {
       await warnIfNonStandardDatasourceUrl({ force });
     }
+    if (sides.includes("web")) {
+      assertSingleViteVersion();
+    }
     const runCommand = async () => {
-      await runBin("jest", jestArgs, {
+      await runBin("vitest", vitestArgs, {
         cwd: rwjsPaths.base,
         stdio: "inherit",
         env: {

package/dist/commands/test/viteVersionCheck.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { getPaths } from "@cedarjs/project-config";
+function resolvePackage(fromFile, packageName) {
+  try {
+    const require2 = createRequire(fromFile);
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(
+      fs.readFileSync(packageJsonPath, "utf-8")
+    );
+    if (typeof packageJson !== "object" || packageJson === null || !("version" in packageJson) || typeof packageJson.version !== "string") {
+      return void 0;
+    }
+    return {
+      version: packageJson.version,
+      dir: path.dirname(packageJsonPath)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function resolveViteVersions({
+  projectBase,
+  webBase
+}) {
+  const vitest = resolvePackage(
+    path.join(projectBase, "package.json"),
+    "vitest"
+  );
+  const vitestVite = vitest ? resolvePackage(path.join(vitest.dir, "package.json"), "vite") : void 0;
+  const cedarVite = resolvePackage(
+    path.join(webBase, "package.json"),
+    "@cedarjs/vite"
+  );
+  const frameworkVite = cedarVite ? resolvePackage(path.join(cedarVite.dir, "package.json"), "vite") : void 0;
+  return { vitestVite, frameworkVite };
+}
+function getViteVersionMismatchMessage({
+  vitestVite,
+  frameworkVite
+}) {
+  if (!vitestVite || !frameworkVite) {
+    return void 0;
+  }
+  if (vitestVite.version === frameworkVite.version) {
+    return void 0;
+  }
+  return `Vitest is using Vite ${vitestVite.version} from
+  ${vitestVite.dir}
+but CedarJS is built against Vite ${frameworkVite.version} from
+  ${frameworkVite.dir}
+
+The CedarJS Vite plugins only work with the Vite version they're built against, so web tests can't run while Vitest uses a different copy. This happens when the project doesn't pin \`vite\`, because Vitest accepts a wide range of Vite versions and installs the newest one.
+
+Please add an override/resolution that pins vite to ${frameworkVite.version}, then reinstall your dependencies.`;
+}
+function assertSingleViteVersion() {
+  const cedarPaths = getPaths();
+  const message = getViteVersionMismatchMessage(
+    resolveViteVersions({
+      projectBase: cedarPaths.base,
+      webBase: cedarPaths.web.base
+    })
+  );
+  if (message) {
+    console.error(message);
+    process.exit(1);
+  }
+}
+export {
+  assertSingleViteVersion,
+  getViteVersionMismatchMessage,
+  resolveViteVersions
+};