@cedarjs/cli 5.0.7-next.338 → 5.0.7

package/dist/commands/setup/neon/neon.js

@@ -7,25 +7,15 @@ function builder(yargs) {
     default: false,
     description: "Overwrite existing DATABASE_URL in .env",
     type: "boolean"
-  }).option("migrations", {
-    description: "Run Prisma migrations after setup. Omit to be prompted. Use --no-migrations to skip.",
-    type: "boolean"
-  }).option("verbose", {
-    alias: "v",
-    default: false,
-    description: "Show full output from migration commands (stderr visible in terminal)",
-    type: "boolean"
   });
 }
-async function handler({ force, migrations, verbose }) {
+async function handler({ force }) {
   recordTelemetryAttributes({
     command: "setup neon",
-    force,
-    migrations,
-    verbose
+    force
   });
   const { handler: handler2 } = await import("./neonHandler.js");
-  return handler2({ force, migrations, verbose });
+  return handler2({ force });
 }
 export {
   builder,

package/dist/commands/setup/neon/neonHandler.js

@@ -2,116 +2,214 @@ import fs from "node:fs";
 import path from "node:path";
 import execa from "execa";
 import { Listr } from "listr2";
-import prompts from "prompts";
 import { colors, getPaths, installPackages } from "@cedarjs/cli-helpers";
-import { prettyPrintCedarCommand } from "@cedarjs/cli-helpers/packageManager";
+import { addWorkspacePackages } from "@cedarjs/cli-helpers/packageManager/packages";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import {
-  checkProjectShape,
-  getSqliteToPostgresTasks
-} from "../database/postgresHandler.js";
-function isPostgresConnectionString(rawValue) {
-  let value = rawValue.trim();
-  const quoted = value.match(/^(['"])(.*)\1$/);
-  if (quoted) {
-    value = quoted[2];
-  }
-  if (!value) {
-    return false;
-  }
-  try {
-    const url = new URL(value);
-    return (url.protocol === "postgres:" || url.protocol === "postgresql:") && !!url.hostname;
-  } catch {
-    return false;
-  }
-}
-async function handler({ force, migrations, verbose }) {
-  const cedarPaths = getPaths();
-  const shape = checkProjectShape(cedarPaths);
-  if (!shape.ok) {
-    if (shape.alreadyConverted) {
-      console.log(colors.note(shape.message));
-      return;
-    }
-    console.error(colors.error(shape.message));
-    process.exit(1);
-  }
+const cedarPaths = getPaths();
+async function handler({ force }) {
+  const schemaPath = path.join(cedarPaths.api.base, "db", "schema.prisma");
+  const dbTsPath = path.join(cedarPaths.api.src, "lib", "db.ts");
+  const prismaConfigPathCjs = path.join(
+    cedarPaths.api.base,
+    "prisma.config.cjs"
+  );
+  const prismaConfigPathMts = path.join(
+    cedarPaths.api.base,
+    "prisma.config.mts"
+  );
   const envPath = path.join(cedarPaths.base, ".env");
-  let hasExistingDatabaseUrl = false;
+  const rootPkgPath = path.join(cedarPaths.base, "package.json");
+  const apiPkgPath = path.join(cedarPaths.api.base, "package.json");
+  const dbTsTemplatePath = path.join(
+    import.meta.dirname,
+    "templates",
+    "db.ts.template"
+  );
+  let hasDirectDatabaseUrl = false;
   if (fs.existsSync(envPath)) {
-    const match = fs.readFileSync(envPath, "utf-8").match(/^DATABASE_URL=(.*)$/m);
-    hasExistingDatabaseUrl = !!match?.[1] && isPostgresConnectionString(match[1]);
-  }
-  const skipProvisioning = hasExistingDatabaseUrl && !force;
-  const notes = [];
-  if (skipProvisioning) {
-    notes.push(
-      colors.note(
-        "DATABASE_URL is already set in .env. Use --force to overwrite."
-      )
+    hasDirectDatabaseUrl = /^DATABASE_URL=/m.test(
+      fs.readFileSync(envPath, "utf-8")
     );
   }
-  let runMigrations = migrations;
-  if (!skipProvisioning && runMigrations === void 0) {
-    if (!process.stdin.isTTY) {
-      const error = new Error(
-        "Cannot prompt for confirmation in a non-interactive terminal. Please pass --migrations or --no-migrations explicitly."
-      );
-      errorTelemetry(process.argv, error.message);
-      console.error(colors.error(error.message));
-      process.exit(1);
-    }
-    const response = await prompts({
-      type: "toggle",
-      name: "runMigrations",
-      message: "Run Prisma migrations now?",
-      initial: true,
-      active: "Yes",
-      inactive: "No"
-    });
-    if (response.runMigrations === void 0) {
-      process.exit(0);
-    }
-    runMigrations = response.runMigrations;
-  }
+  const notes = [];
   const tasks = new Listr(
     [
-      ...getSqliteToPostgresTasks({ dbPath: shape.dbPath }),
       {
-        title: "Setting DIRECT_DATABASE_URL in Prisma config",
-        skip: () => skipProvisioning,
-        task: (ctx, task) => {
-          const prismaConfigPathCjs = path.join(
-            cedarPaths.api.base,
-            "prisma.config.cjs"
-          );
-          const prismaConfigPathMts = path.join(
-            cedarPaths.api.base,
-            "prisma.config.mts"
-          );
-          const configPath = fs.existsSync(prismaConfigPathCjs) ? prismaConfigPathCjs : prismaConfigPathMts;
-          const configContent = fs.readFileSync(configPath, "utf-8");
-          const datasourceUrlRegex = /(\burl\s*:\s*)env\(["'][^"']*?["']\)/;
-          if (!datasourceUrlRegex.test(configContent)) {
-            ctx.directDatabaseUrlNotSet = true;
-            task.skip(
-              "Could not set DIRECT_DATABASE_URL. Please manually set datasource.url in " + configPath
+        title: "Checking current database configuration",
+        task: (ctx) => {
+          const schemaContent = fs.readFileSync(schemaPath, "utf-8");
+          ctx.schemaContent = schemaContent;
+          ctx.isSqlite = schemaContent.includes('provider = "sqlite"');
+          ctx.isPostgres = schemaContent.includes('provider = "postgresql"');
+          if (fs.existsSync(dbTsPath)) {
+            ctx.dbTsContent = fs.readFileSync(dbTsPath, "utf-8");
+            ctx.isNeon = ctx.dbTsContent.includes("PrismaPg");
+          } else {
+            ctx.isNeon = false;
+          }
+          if (!ctx.isSqlite && !ctx.isPostgres) {
+            ctx.unsupportedProvider = true;
+            notes.push(
+              colors.note(
+                "setup neon only supports migrating from SQLite to PostgreSQL. Your project uses a different database provider."
+              )
             );
             return;
           }
-          fs.writeFileSync(
-            configPath,
-            configContent.replace(
-              datasourceUrlRegex,
-              "$1env('DIRECT_DATABASE_URL')"
-            )
+          if (!ctx.isPostgres) {
+            ctx.hasSqliteUsageOutsideDb = hasSqliteUsageOutsideDb(
+              cedarPaths.api.src,
+              dbTsPath
+            );
+          }
+          if (hasDirectDatabaseUrl && !force) {
+            ctx.skipWithNote = true;
+            notes.push(
+              colors.note(
+                "DATABASE_URL is already set in .env. Use --force to overwrite."
+              )
+            );
+          }
+        }
+      },
+      {
+        title: "Removing SQLite dependencies from api/package.json",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isPostgres) {
+            return "Already configured for PostgreSQL";
+          }
+          if (ctx.hasSqliteUsageOutsideDb) {
+            return "SQLite is in use outside db.ts \u2014 keeping packages";
+          }
+          return false;
+        },
+        task: () => {
+          const pkg = JSON.parse(fs.readFileSync(apiPkgPath, "utf-8"));
+          if (pkg.dependencies) {
+            delete pkg.dependencies["better-sqlite3"];
+            delete pkg.dependencies["@prisma/adapter-better-sqlite3"];
+          }
+          fs.writeFileSync(apiPkgPath, JSON.stringify(pkg, null, 2) + "\n");
+        }
+      },
+      {
+        title: "Removing better-sqlite3 dependenciesMeta",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isPostgres) {
+            return "Already configured for PostgreSQL";
+          }
+          if (ctx.hasSqliteUsageOutsideDb) {
+            return "SQLite is in use outside db.ts so we're keeping it installed";
+          }
+          return false;
+        },
+        task: () => {
+          if (!fs.existsSync(rootPkgPath)) {
+            return;
+          }
+          const pkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
+          if (pkg.dependenciesMeta?.["better-sqlite3"]) {
+            delete pkg.dependenciesMeta["better-sqlite3"];
+            if (Object.keys(pkg.dependenciesMeta).length === 0) {
+              delete pkg.dependenciesMeta;
+            }
+            fs.writeFileSync(rootPkgPath, JSON.stringify(pkg, null, 2) + "\n");
+          }
+        }
+      },
+      {
+        title: "Switching Prisma schema to PostgreSQL",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isPostgres) {
+            return "Schema is already configured for PostgreSQL";
+          }
+          return false;
+        },
+        task: (ctx) => {
+          const updated = ctx.schemaContent.replace(
+            'provider = "sqlite"',
+            'provider = "postgresql"'
+          );
+          fs.writeFileSync(schemaPath, updated);
+        }
+      },
+      {
+        title: "Updating database adapter",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isNeon) {
+            return "Database adapter is already configured for Neon (PrismaPg)";
+          }
+          if (ctx.skipWithNote) {
+            return "DATABASE_URL already configured \u2014 skipping adapter update";
+          }
+          return false;
+        },
+        task: () => {
+          const neonDbTs = fs.readFileSync(dbTsTemplatePath, "utf-8");
+          fs.writeFileSync(dbTsPath, neonDbTs);
+        }
+      },
+      {
+        title: "Updating Prisma config",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return "Unsupported database provider";
+          }
+          if (ctx.isNeon) {
+            return "Prisma config is already configured for Neon";
+          }
+          if (ctx.skipWithNote) {
+            return "DATABASE_URL already configured \u2014 skipping config update";
+          }
+          return false;
+        },
+        task: () => {
+          if (!fs.existsSync(prismaConfigPathCjs) && !fs.existsSync(prismaConfigPathMts)) {
+            throw new Error(
+              "No Prisma config file found. Expected prisma.config.cjs or prisma.config.mts in the api directory."
+            );
+          }
+          const configPath = fs.existsSync(prismaConfigPathCjs) ? prismaConfigPathCjs : prismaConfigPathMts;
+          const configContent = fs.readFileSync(configPath, "utf-8");
+          const updated = configContent.replace(
+            /env\(["']DATABASE_URL["']\)/,
+            "env('DIRECT_DATABASE_URL')"
           );
+          fs.writeFileSync(configPath, updated);
+        }
+      },
+      {
+        title: "Adding required api packages...",
+        skip: (ctx) => ctx.unsupportedProvider,
+        task: async () => {
+          await addWorkspacePackages("api", ["@prisma/adapter-pg@7.8.0"], {
+            cwd: cedarPaths.api.base
+          });
         }
       },
       {
         title: "Provisioning Neon database",
-        skip: () => skipProvisioning,
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return true;
+          }
+          if (hasDirectDatabaseUrl && !force) {
+            return true;
+          }
+          return false;
+        },
         task: async (ctx) => {
           const res = await fetch("https://neon.new/api/v1/database", {
             method: "POST",
@@ -141,18 +239,54 @@ async function handler({ force, migrations, verbose }) {
           ctx.neonClaimExpiry = new Date(data.expires_at).toUTCString();
         }
       },
+      {
+        title: "Writing database connection to .env",
+        skip: (ctx) => {
+          if (ctx.unsupportedProvider) {
+            return true;
+          }
+          if (hasDirectDatabaseUrl && !force) {
+            return true;
+          }
+          if (!ctx.databaseUrl) {
+            return "No database URL to write (Neon provisioning skipped)";
+          }
+          return false;
+        },
+        task: (ctx) => {
+          let envContent = "";
+          if (fs.existsSync(envPath)) {
+            envContent = fs.readFileSync(envPath, "utf-8");
+            if (force) {
+              const lines = envContent.split("\n");
+              const filtered = lines.filter(
+                (line) => !line.startsWith("DATABASE_URL=") && !line.startsWith("DIRECT_DATABASE_URL=")
+              );
+              envContent = filtered.join("\n").trimEnd();
+            }
+            if (envContent && !envContent.endsWith("\n")) {
+              envContent += "\n";
+            }
+          }
+          envContent += `DATABASE_URL=${ctx.databaseUrl}
+`;
+          envContent += `DIRECT_DATABASE_URL=${ctx.databaseUrlDirect}
+`;
+          fs.writeFileSync(envPath, envContent);
+        }
+      },
       installPackages,
       {
         title: "Running Prisma migrations",
         skip: (ctx) => {
-          if (skipProvisioning) {
+          if (ctx.unsupportedProvider) {
             return true;
           }
-          if (!runMigrations) {
-            return migrations === false ? "Skipped (--no-migrations)" : "Skipped";
+          if (ctx.skipWithNote) {
+            return "DATABASE_URL already configured \u2014 skipping migration";
           }
-          if (ctx.directDatabaseUrlNotSet) {
-            return `Skipping migrations \u2014 could not confirm prisma.config is reading DIRECT_DATABASE_URL, so migrations could target the wrong database. Fix datasource.url, then run \`${prettyPrintCedarCommand(["prisma", "migrate", "dev"])}\` manually.`;
+          if (!ctx.databaseUrl) {
+            return "No database provisioned \u2014 skipping migration";
           }
           return false;
         },
@@ -161,7 +295,7 @@ async function handler({ force, migrations, verbose }) {
             "yarn cedar prisma migrate dev --name init-neon",
             {
               cwd: cedarPaths.base,
-              stdio: verbose ? "inherit" : ["inherit", "inherit", "pipe"],
+              stdio: ["inherit", "inherit", "pipe"],
               reject: false,
               env: {
                 ...process.env,
@@ -171,50 +305,19 @@ async function handler({ force, migrations, verbose }) {
           );
           if (result.exitCode !== 0) {
             throw new Error(
-              verbose ? `Prisma migration failed. You can try running it manually:
-  ${prettyPrintCedarCommand(["prisma", "migrate", "dev", "--name", "init-neon"])}` : "Prisma migration failed:\n\n" + result.stderr + `
-
-You can try running it manually:
-  ${prettyPrintCedarCommand(["prisma", "migrate", "dev", "--name", "init-neon"])}`
-            );
-          }
-        }
-      },
-      {
-        title: "Writing database connection to .env",
-        // Deliberately runs after migrations, not before — with
-        // `exitOnError: true`, a migration failure stops the list here and
-        // this task never runs. That means a project whose migrations
-        // failed never has DATABASE_URL/DIRECT_DATABASE_URL written to
-        // .env, so it's never left pointing at a Neon database it doesn't
-        // know it needs to claim. Provisioning that database anyway (and
-        // letting it expire unclaimed) is fine — it's exactly as if the
-        // command were re-run from scratch, which is safe.
-        skip: () => skipProvisioning,
-        task: (ctx) => {
-          let envContent = "";
-          if (fs.existsSync(envPath)) {
-            envContent = fs.readFileSync(envPath, "utf-8");
-            const lines = envContent.split("\n");
-            const filtered = lines.filter(
-              (line) => !line.startsWith("DATABASE_URL=") && !line.startsWith("DIRECT_DATABASE_URL=")
+              "Prisma migration failed:\n\n" + result.stderr + "\n\nYou can try running it manually:\n  yarn cedar prisma migrate dev --name init-neon"
             );
-            envContent = filtered.join("\n").trimEnd();
-            if (envContent && !envContent.endsWith("\n")) {
-              envContent += "\n";
-            }
           }
-          envContent += `DATABASE_URL=${ctx.databaseUrl}
-`;
-          envContent += `DIRECT_DATABASE_URL=${ctx.databaseUrlDirect}
-`;
-          fs.writeFileSync(envPath, envContent);
         }
       },
       {
         title: "One more thing...",
         task: (ctx, task) => {
-          if (skipProvisioning) {
+          if (ctx.unsupportedProvider) {
+            task.output = "Skipped \u2014 unsupported database provider";
+            return;
+          }
+          if (ctx.skipWithNote) {
             task.output = "Skipped \u2014 DATABASE_URL already configured";
             return;
           }
@@ -233,11 +336,7 @@ You can try running it manually:
       }
     ],
     {
-      // Migrations run before .env is written (see above) specifically so
-      // that a failure here — the one step that shouldn't be allowed to
-      // continue — stops the whole list via the default exitOnError
-      // behavior, rather than needing every later task to know to skip.
-      exitOnError: true
+      exitOnError: false
     }
   );
   try {
@@ -263,6 +362,24 @@ function isErrorWithMessage(e) {
 function isErrorWithExitCode(e) {
   return !!e && typeof e === "object" && "exitCode" in e && typeof e.exitCode === "number";
 }
+function hasSqliteUsageOutsideDb(srcPath, dbTsPath) {
+  const sqlitePattern = /better-sqlite3|@prisma\/adapter-better-sqlite3/;
+  const files = fs.globSync("**/*.{ts,tsx,js,jsx}", { cwd: srcPath });
+  for (const file of files) {
+    const fullPath = path.join(srcPath, file);
+    if (fullPath === dbTsPath) {
+      continue;
+    }
+    try {
+      const content = fs.readFileSync(fullPath, "utf-8");
+      if (sqlitePattern.test(content)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
 export {
   handler
 };

package/dist/commands/setup/ui/libraries/chakra-uiHandler.js

@@ -54,9 +54,7 @@ async function handler({
           insertComponent: {
             name: "ChakraProvider",
             props: { theme: "extendedTheme" },
-            // Older projects (created before CedarProvider replaced the
-            // deprecated RedwoodProvider) may still use RedwoodProvider.
-            within: "CedarProvider|RedwoodProvider",
+            within: "RedwoodProvider",
             insertBefore: "<ColorModeScript />"
           },
           imports: [

package/dist/commands/setup/ui/libraries/mantineHandler.js

@@ -77,9 +77,7 @@ async function handler({
           insertComponent: {
             name: "MantineProvider",
             props: { theme: "theme" },
-            // Older projects (created before CedarProvider replaced the
-            // deprecated RedwoodProvider) may still use RedwoodProvider.
-            within: "CedarProvider|RedwoodProvider"
+            within: "RedwoodProvider"
           },
           imports: [
             "import { MantineProvider } from '@mantine/core'",

package/dist/commands/setup/ui/libraries/tailwindcssHandler.js

@@ -87,6 +87,7 @@ const handler = async ({
   const projectPackages = ["prettier-plugin-tailwindcss@^0.8.0"];
   const webWorkspacePackages = [
     "postcss",
+    "postcss-loader",
     "tailwindcss@^3.4.17",
     "autoprefixer"
   ];

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

@@ -15,10 +15,9 @@ import { isTypeScriptProject } from "../../../lib/project.js";
 import { runTransform } from "../../../lib/runTransform.js";
 const handler = async ({ force }) => {
   const projectIsTypescript = isTypeScriptProject();
-  const packageJson = await import(path.join(getPaths().base, "package.json"), {
-    with: { type: "json" }
-  });
-  const cedarVersion = packageJson.default.devDependencies["@cedarjs/core"] ?? "latest";
+  const redwoodVersion = await import(path.join(getPaths().base, "package.json"), {
+    with: { type: "json " }
+  }).default.devDependencies["@cedarjs/core"] ?? "latest";
   const tasks = new Listr(
     [
       {
@@ -66,7 +65,7 @@ const handler = async ({ force }) => {
         }
       },
       {
-        ...addApiPackages([`@cedarjs/storage@${cedarVersion}`]),
+        ...addApiPackages([`@cedarjs/storage@${redwoodVersion}`]),
         title: "Adding dependencies to your api side..."
       },
       {
@@ -83,7 +82,7 @@ const handler = async ({ force }) => {
           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"
+                "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/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"
               );
             }
             throw new Error(

package/dist/commands/setup.js

@@ -2,7 +2,6 @@ import { terminalLink } from "termi-link";
 import { detectCedarVersion } from "../middleware/detectProjectCedarVersion.js";
 import * as setupAuth from "./setup/auth/auth.js";
 import * as setupCache from "./setup/cache/cache.js";
-import * as setupDatabase from "./setup/database/database.js";
 import * as setupDeploy from "./setup/deploy/deploy.js";
 import * as setupDocker from "./setup/docker/docker.js";
 import * as setupGenerator from "./setup/generator/generator.js";
@@ -21,7 +20,7 @@ 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(setupTsconfig).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).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(setupTsconfig).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/test/testHandlerEsm.js

@@ -59,10 +59,10 @@ const handler = async ({
     vitestArgs.push("--run");
   }
   if (!others["config"]) {
-    sides.forEach((side) => vitestArgs.push("--project", side));
     if (!sides.length) {
       project.workspaces().forEach((side) => sides.push(side));
     }
+    sides.forEach((side) => vitestArgs.push("--project", side));
   }
   try {
     const cacheDirDb = `file:${ensurePosixPath(

package/dist/commands/upgrade/preUpgradeScripts.js

@@ -4,7 +4,6 @@ import os from "node:os";
 import path from "node:path";
 import execa from "execa";
 import semver from "semver";
-const MAIN_BRANCH_PRERELEASE_TAGS = ["canary"];
 function isExecaError(e) {
   return e instanceof Error && ("stdout" in e || "stderr" in e || "exitCode" in e);
 }
@@ -34,15 +33,8 @@ async function runPreUpgradeScripts(ctx, task, { verbose, force }) {
   if (!Array.isArray(manifest) || manifest.length === 0) {
     return;
   }
-  const prereleaseTag = parsed?.prerelease[0];
-  const isMainBranchPrerelease = typeof prereleaseTag === "string" && MAIN_BRANCH_PRERELEASE_TAGS.includes(prereleaseTag);
   const checkLevels = [];
-  if (parsed && isMainBranchPrerelease) {
-    checkLevels.push({
-      id: "tag",
-      candidates: [`${prereleaseTag}.ts`, `${prereleaseTag}/index.ts`]
-    });
-  } else if (parsed) {
+  if (parsed && !parsed.prerelease.length) {
     checkLevels.push({
       id: "exact",
       candidates: [`${version}.ts`, `${version}/index.ts`]
@@ -58,6 +50,14 @@ async function runPreUpgradeScripts(ctx, task, { verbose, force }) {
       id: "minor",
       candidates: [`${parsed.major}.x.ts`, `${parsed.major}.x/index.ts`]
     });
+  } else if (parsed && parsed.prerelease.length > 0) {
+    checkLevels.push({
+      id: "tag",
+      candidates: [
+        `${parsed.prerelease[0]}.ts`,
+        `${parsed.prerelease[0]}/index.ts`
+      ]
+    });
   }
   const scriptsToRun = [];
   for (const level of checkLevels) {