@cedarjs/codemods 3.0.0-canary.13607 → 3.0.0-canary.13610

package/dist/codemods/v3.x/prismaV7/prismaV7.js

@@ -0,0 +1,72 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getSchemaPath, getPaths } from "@cedarjs/project-config";
+import runTransform from "../../../lib/runTransform.js";
+import rewriteRemainingImports from "./rewriteRemainingImports.js";
+import { updateApiPackageJson } from "./updateApiPackageJson.js";
+import { checkDotEnv, updateEnvDefaults } from "./updateEnvDefaults.js";
+import { updateGitignore } from "./updateGitignore.js";
+import { updatePrismaConfig } from "./updatePrismaConfig.js";
+import runUpdateSchemaFile from "./updateSchemaFile.js";
+import { updateTsConfigs } from "./updateTsConfigs.js";
+function detectProvider(schemaPath) {
+  if (!fs.existsSync(schemaPath)) {
+    return "sqlite";
+  }
+  const source = fs.readFileSync(schemaPath, "utf-8");
+  const match = source.match(
+    /datasource\s+\w+\s*\{[^}]*provider\s*=\s*["']([^"']+)["']/
+  );
+  return match ? match[1].toLowerCase() : "sqlite";
+}
+async function getPrismaV7Context() {
+  const paths = getPaths();
+  const schemaPath = await getSchemaPath(paths.api.prismaConfig);
+  const provider = detectProvider(schemaPath);
+  const isSqlite = provider === "sqlite";
+  const dbPathTs = path.join(paths.api.lib, "db.ts");
+  const dbPathJs = path.join(paths.api.lib, "db.js");
+  let dbFilePath = null;
+  if (fs.existsSync(dbPathTs)) {
+    dbFilePath = dbPathTs;
+  } else if (fs.existsSync(dbPathJs)) {
+    dbFilePath = dbPathJs;
+  }
+  return { isSqlite, paths, dbFilePath };
+}
+async function prismaV7() {
+  const context = await getPrismaV7Context();
+  const { paths, isSqlite } = context;
+  await runUpdateSchemaFile();
+  await updatePrismaConfig(paths.api.prismaConfig);
+  if (context.dbFilePath) {
+    await runTransform({
+      transformPath: path.join(import.meta.dirname, "updateDbFile.js"),
+      targetPaths: [context.dbFilePath],
+      parser: "ts",
+      options: {
+        isSqlite
+      }
+    });
+  }
+  await rewriteRemainingImports();
+  if (isSqlite) {
+    await updateApiPackageJson(path.join(paths.api.base, "package.json"));
+  }
+  await updateTsConfigs({
+    apiTsConfig: path.join(paths.api.base, "tsconfig.json"),
+    scriptsTsConfig: path.join(paths.base, "scripts", "tsconfig.json"),
+    webTsConfig: path.join(paths.web.base, "tsconfig.json")
+  });
+  await updateGitignore(path.join(paths.base, ".gitignore"));
+  await updateEnvDefaults(path.join(paths.base, ".env.defaults"));
+  const dotEnvWarning = checkDotEnv(path.join(paths.base, ".env"));
+  if (dotEnvWarning) {
+    console.warn(`
+Warning: ${dotEnvWarning}`);
+  }
+}
+export {
+  prismaV7 as default,
+  getPrismaV7Context
+};

package/dist/codemods/v3.x/prismaV7/prismaV7.yargs.js

@@ -0,0 +1,164 @@
+import path from "node:path";
+import task from "tasuku";
+import runTransform from "../../../lib/runTransform.js";
+import { getPrismaV7Context } from "./prismaV7.js";
+import rewriteRemainingImports from "./rewriteRemainingImports.js";
+import { updateApiPackageJson } from "./updateApiPackageJson.js";
+import { checkDotEnv, updateEnvDefaults } from "./updateEnvDefaults.js";
+import { updateGitignore } from "./updateGitignore.js";
+import { updatePrismaConfig } from "./updatePrismaConfig.js";
+import runUpdateSchemaFile from "./updateSchemaFile.js";
+import { updateTsConfigs } from "./updateTsConfigs.js";
+const command = "prisma-v7";
+const description = "(v3.x) Upgrades your Cedar app to use Prisma v7 \u2014 updates schema.prisma, db.ts, prisma.config.cjs, and related config files";
+const handler = async () => {
+  const context = await getPrismaV7Context();
+  const { paths, isSqlite, dbFilePath } = context;
+  await task("Prisma v7 Migration", async ({ task: task2 }) => {
+    await task2.group(
+      (task3) => [
+        task3("Update schema.prisma", async ({ setOutput }) => {
+          const { results } = await runUpdateSchemaFile();
+          for (const result of results) {
+            if (result.status === "skipped") {
+              setOutput(`Skipped \u2014 ${result.path} not found`);
+            } else if (result.status === "unmodified") {
+              setOutput("No changes needed (already migrated)");
+            } else {
+              setOutput(`Updated ${result.path}`);
+            }
+            for (const warning of result.warnings) {
+              console.warn(`
+\u26A0\uFE0F  ${warning}`);
+            }
+          }
+          if (results.length === 0) {
+            setOutput("Skipped \u2014 no schema.prisma found");
+          }
+        }),
+        task3("Update prisma.config.cjs", async ({ setOutput }) => {
+          const result = await updatePrismaConfig(paths.api.prismaConfig);
+          if (result === "skipped") {
+            setOutput("Skipped \u2014 prisma.config.cjs not found");
+          } else if (result === "unmodified") {
+            setOutput("No changes needed (already has datasource block)");
+          } else {
+            setOutput(`Updated ${paths.api.prismaConfig}`);
+          }
+        }),
+        task3("Update api/src/lib/db.{ts,js}", async ({ setOutput }) => {
+          if (!dbFilePath) {
+            setOutput(
+              "Skipped \u2014 no api/src/lib/db.ts or api/src/lib/db.js found"
+            );
+            return;
+          }
+          await runTransform({
+            transformPath: path.join(import.meta.dirname, "updateDbFile.js"),
+            targetPaths: [dbFilePath],
+            parser: "ts",
+            options: {
+              isSqlite
+            }
+          });
+          setOutput(`Updated ${dbFilePath}`);
+          if (!isSqlite) {
+            console.log(
+              "\n\u2139\uFE0F  Non-SQLite database detected. The import paths in db.ts have\n   been updated, but no driver adapter was added. If you want to\n   use a Prisma driver adapter (recommended), add one manually.\n   See: https://www.prisma.io/docs/orm/overview/databases/database-drivers"
+            );
+          }
+        })
+      ],
+      { concurrency: 1 }
+    );
+    await task2.group(
+      (task3) => [
+        task3(
+          "Rewrite remaining @prisma/client imports",
+          async ({ setOutput }) => {
+            await rewriteRemainingImports();
+            setOutput("Done");
+          }
+        ),
+        task3("Update api/package.json", async ({ setOutput }) => {
+          if (!isSqlite) {
+            setOutput(
+              "Skipped \u2014 non-SQLite project. Add your own driver adapter package."
+            );
+            return;
+          }
+          const pkgPath = path.join(paths.api.base, "package.json");
+          const result = await updateApiPackageJson(pkgPath);
+          if (result === "skipped") {
+            setOutput("Skipped \u2014 api/package.json not found");
+          } else if (result === "unmodified") {
+            setOutput("No changes needed (adapter already installed)");
+          } else {
+            setOutput(`Updated ${pkgPath}`);
+          }
+        }),
+        task3("Update tsconfig.json files", async ({ setOutput }) => {
+          const results = await updateTsConfigs({
+            apiTsConfig: path.join(paths.api.base, "tsconfig.json"),
+            scriptsTsConfig: path.join(paths.base, "scripts", "tsconfig.json"),
+            webTsConfig: path.join(paths.web.base, "tsconfig.json")
+          });
+          const updated = Object.entries(results).filter(([, status]) => status === "updated").map(([name]) => name);
+          if (updated.length === 0) {
+            setOutput("No changes needed");
+          } else {
+            setOutput(`Updated: ${updated.join(", ")}`);
+          }
+        }),
+        task3("Update .gitignore", async ({ setOutput }) => {
+          const gitignorePath = path.join(paths.base, ".gitignore");
+          const result = await updateGitignore(gitignorePath);
+          if (result === "skipped") {
+            setOutput("Skipped \u2014 .gitignore not found");
+          } else if (result === "unmodified") {
+            setOutput("No changes needed");
+          } else {
+            setOutput(`Updated ${gitignorePath}`);
+          }
+        }),
+        task3("Update .env.defaults", async ({ setOutput }) => {
+          const envDefaultsPath = path.join(paths.base, ".env.defaults");
+          const result = await updateEnvDefaults(envDefaultsPath);
+          if (result === "skipped") {
+            setOutput("Skipped \u2014 .env.defaults not found");
+          } else if (result === "unmodified") {
+            setOutput("No changes needed");
+          } else {
+            setOutput(`Updated ${envDefaultsPath}`);
+          }
+          const dotEnvWarning = checkDotEnv(path.join(paths.base, ".env"));
+          if (dotEnvWarning) {
+            console.warn(`
+\u26A0\uFE0F  ${dotEnvWarning}`);
+          }
+        })
+      ],
+      { concurrency: Infinity }
+    );
+    await task2("Next steps", async ({ setOutput }) => {
+      const steps = [
+        "  1. Run `yarn install` to install new dependencies",
+        "  2. Run `yarn cedar prisma generate` to generate the new Prisma client",
+        "  3. Run `yarn cedar prisma migrate dev` to verify migrations work",
+        "  4. Run `yarn cedar lint --fix` to fix any import ordering issues"
+      ];
+      if (!isSqlite) {
+        steps.push(
+          "  5. Add a Prisma driver adapter for your database to api/src/lib/db.ts",
+          "     See: https://www.prisma.io/docs/orm/overview/databases/database-drivers"
+        );
+      }
+      setOutput("\n\n" + steps.join("\n"));
+    });
+  });
+};
+export {
+  command,
+  description,
+  handler
+};

package/dist/codemods/v3.x/prismaV7/rewriteRemainingImports.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  ensurePosixPath,
+  getDataMigrationsPath,
+  getPaths
+} from "@cedarjs/project-config";
+const CODE_FILE_GLOB = "**/*.{ts,tsx,cts,mts,js,jsx,cjs,mjs}";
+async function collectCodeFiles(dir) {
+  try {
+    return await Array.fromAsync(fs.promises.glob(CODE_FILE_GLOB, { cwd: dir }));
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function rewritePrismaImportsInDirectory(dir, dbFilePath) {
+  const scriptsDir = ensurePosixPath(getPaths().scripts);
+  const normalizedDbFilePath = dbFilePath ? ensurePosixPath(dbFilePath) : null;
+  const fileMatches = await collectCodeFiles(dir);
+  const files = fileMatches.map((relativePath) => path.join(dir, relativePath)).filter((filePath) => ensurePosixPath(filePath) !== normalizedDbFilePath);
+  if (files.length === 0) {
+    return "skipped";
+  }
+  let anyUpdated = false;
+  for (const filePath of files) {
+    const source = await fs.promises.readFile(filePath, "utf-8");
+    const isScriptFile = ensurePosixPath(filePath).startsWith(scriptsDir);
+    const importPath = isScriptFile ? "api/src/lib/db" : "src/lib/db";
+    const importPattern = /(['"])@prisma\/client\1/g;
+    const transformed = source.replace(importPattern, `$1${importPath}$1`);
+    if (transformed !== source) {
+      await fs.promises.writeFile(filePath, transformed);
+      anyUpdated = true;
+    }
+  }
+  return anyUpdated ? "updated" : "skipped";
+}
+async function rewriteRemainingImports() {
+  const paths = getPaths();
+  const prismaConfigPath = paths.api.prismaConfig;
+  const dataMigrationsPath = await getDataMigrationsPath(prismaConfigPath);
+  const dbPathTs = path.join(paths.api.lib, "db.ts");
+  const dbPathJs = path.join(paths.api.lib, "db.js");
+  let dbFilePath = null;
+  if (fs.existsSync(dbPathTs)) {
+    dbFilePath = dbPathTs;
+  } else if (fs.existsSync(dbPathJs)) {
+    dbFilePath = dbPathJs;
+  }
+  const dirsToTransform = [paths.api.src, dataMigrationsPath, paths.scripts];
+  for (const dir of dirsToTransform) {
+    await rewritePrismaImportsInDirectory(dir, dbFilePath);
+  }
+}
+export {
+  rewriteRemainingImports as default,
+  rewritePrismaImportsInDirectory
+};

package/dist/codemods/v3.x/prismaV7/updateApiPackageJson.js

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+const ADAPTER_PACKAGE = "@prisma/adapter-better-sqlite3";
+const SQLITE_PACKAGE = "better-sqlite3";
+const ADAPTER_VERSION = "^7.0.0";
+const SQLITE_VERSION = "^12.0.0";
+function transformApiPackageJson(source, adapterVersion = ADAPTER_VERSION, sqliteVersion = SQLITE_VERSION) {
+  const pkg = JSON.parse(source);
+  if (pkg.dependencies?.[ADAPTER_PACKAGE]) {
+    return source;
+  }
+  pkg.dependencies = {
+    ...pkg.dependencies ?? {},
+    [ADAPTER_PACKAGE]: adapterVersion,
+    [SQLITE_PACKAGE]: sqliteVersion
+  };
+  const indentMatch = source.match(/^(\s+)"/m);
+  const indent = indentMatch ? indentMatch[1] : "  ";
+  return JSON.stringify(pkg, null, indent.length) + "\n";
+}
+async function updateApiPackageJson(packageJsonPath, adapterVersion = ADAPTER_VERSION, sqliteVersion = SQLITE_VERSION) {
+  if (!fs.existsSync(packageJsonPath)) {
+    return "skipped";
+  }
+  const source = fs.readFileSync(packageJsonPath, "utf-8");
+  const pkg = JSON.parse(source);
+  if (pkg.dependencies?.[ADAPTER_PACKAGE]) {
+    return "unmodified";
+  }
+  const transformed = transformApiPackageJson(
+    source,
+    adapterVersion,
+    sqliteVersion
+  );
+  if (transformed === source) {
+    return "unmodified";
+  }
+  fs.writeFileSync(packageJsonPath, transformed, "utf-8");
+  return "updated";
+}
+export {
+  ADAPTER_PACKAGE,
+  ADAPTER_VERSION,
+  SQLITE_PACKAGE,
+  SQLITE_VERSION,
+  transformApiPackageJson,
+  updateApiPackageJson
+};

package/dist/codemods/v3.x/prismaV7/updateDbFile.js

@@ -0,0 +1,164 @@
+const NEW_CLIENT_PATH = "api/db/generated/prisma/client.mts";
+const OLD_PRISMA_CLIENT = "@prisma/client";
+function transform(file, api, options = {}) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const alreadyMigrated = root.find(j.ImportDeclaration, { source: { value: NEW_CLIENT_PATH } }).length > 0;
+  if (alreadyMigrated) {
+    return file.source;
+  }
+  const isSqlite = options["isSqlite"] !== false;
+  let didTransform = false;
+  root.find(j.ImportDeclaration, { source: { value: OLD_PRISMA_CLIENT } }).forEach((nodePath) => {
+    nodePath.node.source = j.stringLiteral(NEW_CLIENT_PATH);
+    didTransform = true;
+  });
+  root.find(j.ExportAllDeclaration).filter((nodePath) => {
+    const src = nodePath.node.source?.value;
+    return src === OLD_PRISMA_CLIENT || src === "src/lib/db" || src === "api/src/lib/db";
+  }).forEach((nodePath) => {
+    nodePath.node.source = j.stringLiteral(NEW_CLIENT_PATH);
+    didTransform = true;
+  });
+  if (!didTransform) {
+    return file.source;
+  }
+  if (!isSqlite) {
+    return root.toSource({ quote: "single" });
+  }
+  const hasPathImport = root.find(j.ImportDeclaration, { source: { value: "node:path" } }).length > 0;
+  const hasAdapterImport = root.find(j.ImportDeclaration, {
+    source: { value: "@prisma/adapter-better-sqlite3" }
+  }).length > 0;
+  const hasGetPathsImport = root.find(j.ImportDeclaration, {
+    source: { value: "@cedarjs/project-config" }
+  }).length > 0;
+  const allImports = root.find(j.ImportDeclaration);
+  const firstImport = allImports.at(0);
+  if (!hasPathImport) {
+    const pathImport = j.importDeclaration(
+      [j.importDefaultSpecifier(j.identifier("path"))],
+      j.stringLiteral("node:path")
+    );
+    firstImport.insertBefore(pathImport);
+  }
+  const clientImport = root.find(j.ImportDeclaration, {
+    source: { value: NEW_CLIENT_PATH }
+  });
+  if (!hasAdapterImport) {
+    const adapterImport = j.importDeclaration(
+      [
+        j.importSpecifier(
+          j.identifier("PrismaBetterSqlite3"),
+          j.identifier("PrismaBetterSqlite3")
+        )
+      ],
+      j.stringLiteral("@prisma/adapter-better-sqlite3")
+    );
+    clientImport.insertBefore(adapterImport);
+  }
+  if (!hasGetPathsImport) {
+    const cedarjsImports = root.find(
+      j.ImportDeclaration,
+      (node) => String(node.source.value).startsWith("@cedarjs/")
+    );
+    const getPathsImport = j.importDeclaration(
+      [j.importSpecifier(j.identifier("getPaths"), j.identifier("getPaths"))],
+      j.stringLiteral("@cedarjs/project-config")
+    );
+    if (cedarjsImports.length > 0) {
+      cedarjsImports.at(-1).insertAfter(getPathsImport);
+    } else {
+      clientImport.insertAfter(getPathsImport);
+    }
+  }
+  const hasResolveSqliteUrl = root.find(j.VariableDeclarator, {
+    id: { type: "Identifier", name: "resolveSqliteUrl" }
+  }).length > 0;
+  const hasAdapter = root.find(j.VariableDeclarator, {
+    id: { type: "Identifier", name: "adapter" }
+  }).length > 0;
+  const prismaClientNewExpr = root.find(j.NewExpression, {
+    callee: { type: "Identifier", name: "PrismaClient" }
+  });
+  if (prismaClientNewExpr.length > 0 && (!hasResolveSqliteUrl || !hasAdapter)) {
+    const prismaClientDeclaration = prismaClientNewExpr.closest(
+      j.VariableDeclaration
+    );
+    if (!hasResolveSqliteUrl) {
+      const resolveSqliteUrlSource = `
+const resolveSqliteUrl = (url = 'file:./db/dev.db') => {
+  if (!url.startsWith('file:.')) {
+    return url
+  }
+
+  return \`file:\${path.resolve(getPaths().api.base, url.slice('file:'.length))}\`
+}
+`;
+      const resolveSqliteUrlDecl = j(resolveSqliteUrlSource).find(j.VariableDeclaration).get().node;
+      prismaClientDeclaration.insertBefore(resolveSqliteUrlDecl);
+    }
+    if (!hasAdapter) {
+      const adapterDecl = j.variableDeclaration("const", [
+        j.variableDeclarator(
+          j.identifier("adapter"),
+          j.newExpression(j.identifier("PrismaBetterSqlite3"), [
+            j.objectExpression([
+              j.objectProperty(
+                j.identifier("url"),
+                j.callExpression(j.identifier("resolveSqliteUrl"), [
+                  j.memberExpression(
+                    j.memberExpression(
+                      j.identifier("process"),
+                      j.identifier("env")
+                    ),
+                    j.identifier("DATABASE_URL")
+                  )
+                ])
+              )
+            ])
+          ])
+        )
+      ]);
+      prismaClientDeclaration.insertBefore(adapterDecl);
+    }
+  }
+  root.find(j.NewExpression, {
+    callee: { type: "Identifier", name: "PrismaClient" }
+  }).forEach((nodePath) => {
+    const args = nodePath.node.arguments;
+    if (args.length === 0) {
+      nodePath.node.arguments = [
+        j.objectExpression([
+          Object.assign(
+            j.objectProperty(
+              j.identifier("adapter"),
+              j.identifier("adapter")
+            ),
+            { shorthand: true }
+          )
+        ])
+      ];
+      return;
+    }
+    const firstArg = args[0];
+    if (firstArg.type !== "ObjectExpression") {
+      return;
+    }
+    const hasAdapterProp = firstArg.properties.some(
+      (prop) => prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "adapter"
+    );
+    if (!hasAdapterProp) {
+      firstArg.properties.push(
+        Object.assign(
+          j.objectProperty(j.identifier("adapter"), j.identifier("adapter")),
+          { shorthand: true }
+        )
+      );
+    }
+  });
+  return root.toSource({ quote: "single" });
+}
+export {
+  transform as default
+};

package/dist/codemods/v3.x/prismaV7/updateEnvDefaults.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+const OLD_SQLITE_URL = "file:./dev.db";
+const NEW_SQLITE_URL = "file:./db/dev.db";
+function transformEnvDefaults(source) {
+  return source.replace(
+    /^(DATABASE_URL=)file:\.\/dev\.db([ \t]*)$/m,
+    `$1${NEW_SQLITE_URL}$2`
+  );
+}
+async function updateEnvDefaults(envDefaultsPath) {
+  if (!fs.existsSync(envDefaultsPath)) {
+    return "skipped";
+  }
+  const source = fs.readFileSync(envDefaultsPath, "utf-8");
+  if (!source.includes(`DATABASE_URL=${OLD_SQLITE_URL}`)) {
+    return "unmodified";
+  }
+  const transformed = transformEnvDefaults(source);
+  if (transformed === source) {
+    return "unmodified";
+  }
+  fs.writeFileSync(envDefaultsPath, transformed, "utf-8");
+  return "updated";
+}
+function checkDotEnv(envPath) {
+  if (!fs.existsSync(envPath)) {
+    return null;
+  }
+  const source = fs.readFileSync(envPath, "utf-8");
+  if (source.includes(`DATABASE_URL=${OLD_SQLITE_URL}`)) {
+    return `Your .env file still contains DATABASE_URL=${OLD_SQLITE_URL}. You should manually update it to DATABASE_URL=${NEW_SQLITE_URL}.`;
+  }
+  return null;
+}
+export {
+  checkDotEnv,
+  transformEnvDefaults,
+  updateEnvDefaults
+};

package/dist/codemods/v3.x/prismaV7/updateGitignore.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+const GENERATED_PRISMA_ENTRY = "api/db/generated/prisma";
+function transformGitignore(source) {
+  if (source.includes(GENERATED_PRISMA_ENTRY)) {
+    return source;
+  }
+  if (/^dev\.db\*/m.test(source)) {
+    return source.replace(/^(dev\.db\*)$/m, `$1
+${GENERATED_PRISMA_ENTRY}`);
+  }
+  const withTrailingNewline = source.endsWith("\n") ? source : source + "\n";
+  return withTrailingNewline + GENERATED_PRISMA_ENTRY + "\n";
+}
+async function updateGitignore(gitignorePath) {
+  if (!fs.existsSync(gitignorePath)) {
+    return "skipped";
+  }
+  const source = fs.readFileSync(gitignorePath, "utf-8");
+  if (source.includes(GENERATED_PRISMA_ENTRY)) {
+    return "unmodified";
+  }
+  const transformed = transformGitignore(source);
+  if (transformed === source) {
+    return "unmodified";
+  }
+  fs.writeFileSync(gitignorePath, transformed, "utf-8");
+  return "updated";
+}
+export {
+  transformGitignore,
+  updateGitignore
+};

package/dist/codemods/v3.x/prismaV7/updatePrismaConfig.js

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+function transformPrismaConfig(source) {
+  if (/datasource\s*:/.test(source)) {
+    return source;
+  }
+  let result = source;
+  if (!/\benv\b/.test(result)) {
+    result = result.replace(
+      /const\s*\{([^}]*)\}\s*=\s*require\(['"]prisma\/config['"]\)/,
+      (match, destructured) => {
+        const trimmed = destructured.trim();
+        return `const { ${trimmed}, env } = require('prisma/config')`;
+      }
+    );
+  }
+  result = result.replace(
+    /(\n[ \t]*\}[ \t]*,?\s*\n)([ \t]*\}\))/,
+    (match, lastPropClose, closingParen) => {
+      const indent = lastPropClose.match(/^(\n([ \t]*))/)?.[2] ?? "  ";
+      const propIndent = indent;
+      const innerIndent = indent + "  ";
+      return lastPropClose + `${propIndent}datasource: {
+${innerIndent}url: env('DATABASE_URL'),
+${propIndent}},
+` + closingParen;
+    }
+  );
+  return result;
+}
+async function updatePrismaConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return "skipped";
+  }
+  const source = fs.readFileSync(configPath, "utf-8");
+  if (/datasource\s*:/.test(source)) {
+    return "unmodified";
+  }
+  const transformed = transformPrismaConfig(source);
+  if (transformed === source) {
+    return "unmodified";
+  }
+  fs.writeFileSync(configPath, transformed, "utf-8");
+  return "updated";
+}
+export {
+  transformPrismaConfig,
+  updatePrismaConfig
+};

package/dist/codemods/v3.x/prismaV7/updateSchemaFile.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getSchemaPath, getPaths } from "@cedarjs/project-config";
+const NEW_GENERATOR_BLOCK = `generator client {
+  provider               = "prisma-client"
+  output                 = "./generated/prisma"
+  moduleFormat           = "cjs"
+  generatedFileExtension = "mts"
+  importFileExtension    = "mts"
+}`;
+function isAlreadyMigrated(source) {
+  return /generator\s+client\s*\{[^}]*provider\s*=\s*["']prisma-client["'][^}]*\}/.test(
+    source
+  );
+}
+function transformSchema(source) {
+  let directUrlEnvVar = null;
+  let customBinaryTargets = null;
+  const result = source.replace(
+    /(datasource\s+\w+\s*\{)([^}]*?)(\})/g,
+    (_fullMatch, open, body, close) => {
+      const directUrlMatch = body.match(
+        /directUrl\s*=\s*env\(["']([^"']+)["']\)/
+      );
+      if (directUrlMatch) {
+        directUrlEnvVar = directUrlMatch[1];
+      }
+      const cleaned = body.replace(/^[ \t]*url\s*=\s*.+\n?/gm, "").replace(/^[ \t]*directUrl\s*=\s*.+\n?/gm, "").replace(/\n{3,}/g, "\n\n");
+      return `${open}${cleaned}${close}`;
+    }
+  ).replace(
+    /generator\s+client\s*\{([^}]*)\}/g,
+    (_fullMatch, body) => {
+      const binaryMatch = body.match(
+        /binaryTargets\s*=\s*(\[[^\]]*\]|"[^"]*"|'[^']*')/
+      );
+      if (binaryMatch) {
+        const val = binaryMatch[1];
+        if (!/^\s*["']native["']\s*$/.test(val)) {
+          customBinaryTargets = val;
+        }
+      }
+      return NEW_GENERATOR_BLOCK;
+    }
+  );
+  return { result, directUrlEnvVar, customBinaryTargets };
+}
+async function updateSchemaFile(schemaPath) {
+  if (!fs.existsSync(schemaPath)) {
+    return { status: "skipped", warnings: [] };
+  }
+  const source = fs.readFileSync(schemaPath, "utf-8");
+  const warnings = [];
+  if (isAlreadyMigrated(source)) {
+    return { status: "unmodified", warnings };
+  }
+  const { result, directUrlEnvVar, customBinaryTargets } = transformSchema(source);
+  if (directUrlEnvVar) {
+    warnings.push(
+      `A directUrl was found in your schema.prisma and has been removed. In Prisma v7 the \`url\` field in prisma.config.cjs is used by the CLI for migrations (replacing directUrl). Update api/prisma.config.cjs to use your direct URL value there:
+  datasource: {
+    url: env('${directUrlEnvVar}'),
+  },`
+    );
+  }
+  if (customBinaryTargets) {
+    warnings.push(
+      `binaryTargets (${customBinaryTargets}) has been removed from your schema.prisma. binaryTargets is no longer needed in Prisma v7 as the new driver is written in TypeScript.`
+    );
+  }
+  if (result === source) {
+    return { status: "unmodified", warnings };
+  }
+  fs.writeFileSync(schemaPath, result, "utf-8");
+  return { status: "updated", warnings };
+}
+async function runUpdateSchemaFile() {
+  const paths = getPaths();
+  const schemaPath = await getSchemaPath(paths.api.prismaConfig);
+  const results = [];
+  if (schemaPath) {
+    const schemaDir = path.dirname(schemaPath);
+    const siblings = fs.existsSync(schemaDir) ? fs.readdirSync(schemaDir).filter((f) => f.endsWith(".prisma")).map((f) => path.join(schemaDir, f)) : [];
+    const filesToProcess = [
+      schemaPath,
+      ...siblings.filter((f) => f !== schemaPath)
+    ];
+    for (const filePath of filesToProcess) {
+      const result = await updateSchemaFile(filePath);
+      results.push({ path: filePath, ...result });
+    }
+  }
+  return { results };
+}
+export {
+  runUpdateSchemaFile as default,
+  updateSchemaFile
+};

package/dist/codemods/v3.x/prismaV7/updateTsConfigs.js

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+function transformTsConfig(source) {
+  if (/["']allowImportingTsExtensions["']/.test(source)) {
+    return source;
+  }
+  const afterModuleResolution = source.replace(
+    /("moduleResolution"\s*:\s*"[^"]*")(,?)(\s*\n)/,
+    (match, prop, comma, ws) => {
+      const lineStart = source.lastIndexOf("\n", source.indexOf(match)) + 1;
+      const indentMatch = source.slice(lineStart).match(/^([ \t]+)/);
+      const indent = indentMatch ? indentMatch[1] : "    ";
+      const trailingComma = comma || ",";
+      return `${prop}${trailingComma}${ws}${indent}"allowImportingTsExtensions": true,
+`;
+    }
+  );
+  if (afterModuleResolution !== source) {
+    return afterModuleResolution;
+  }
+  const afterModule = source.replace(
+    /("module"\s*:\s*"[^"]*")(,?)(\s*\n)/,
+    (match, prop, comma, ws) => {
+      const lineStart = source.lastIndexOf("\n", source.indexOf(match)) + 1;
+      const indentMatch = source.slice(lineStart).match(/^([ \t]+)/);
+      const indent = indentMatch ? indentMatch[1] : "    ";
+      const trailingComma = comma || ",";
+      return `${prop}${trailingComma}${ws}${indent}"allowImportingTsExtensions": true,
+`;
+    }
+  );
+  if (afterModule !== source) {
+    return afterModule;
+  }
+  return source.replace(
+    /("compilerOptions"\s*:\s*\{)(\s*\n)/,
+    (match, open, ws) => {
+      const lineStart = source.lastIndexOf("\n", source.indexOf(match)) + 1;
+      const indentMatch = source.slice(lineStart).match(/^([ \t]+)/);
+      const outerIndent = indentMatch ? indentMatch[1] : "  ";
+      const innerIndent = outerIndent + "  ";
+      return `${open}${ws}${innerIndent}"allowImportingTsExtensions": true,
+`;
+    }
+  );
+}
+async function updateTsConfig(tsConfigPath) {
+  if (!fs.existsSync(tsConfigPath)) {
+    return "skipped";
+  }
+  const source = fs.readFileSync(tsConfigPath, "utf-8");
+  if (/["']allowImportingTsExtensions["']/.test(source)) {
+    return "unmodified";
+  }
+  const transformed = transformTsConfig(source);
+  if (transformed === source) {
+    return "unmodified";
+  }
+  fs.writeFileSync(tsConfigPath, transformed, "utf-8");
+  return "updated";
+}
+async function updateTsConfigs(paths) {
+  const [api, scripts, web] = await Promise.all([
+    updateTsConfig(paths.apiTsConfig),
+    updateTsConfig(paths.scriptsTsConfig),
+    updateTsConfig(paths.webTsConfig)
+  ]);
+  return { api, scripts, web };
+}
+export {
+  transformTsConfig,
+  updateTsConfig,
+  updateTsConfigs
+};

package/dist/codemods.js

@@ -22,7 +22,8 @@ import * as v6ThemeConfig from "./codemods/redwood/v6.x.x/updateThemeConfig/upda
 import * as v7Gql from "./codemods/redwood/v7.x.x/updateGraphQLConfig/updateGraphqlConfig.yargs.js";
 import * as v2MoveGeneratorTemplates from "./codemods/v2.3.x/moveGeneratorTemplates/moveGeneratorTemplates.yargs.js";
 import * as v2PrismaV7Prep from "./codemods/v2.7.x/prismaV7Prep/prismaV7Prep.yargs.js";
-yargs(hideBin(process.argv)).scriptName("").command(v2MoveGeneratorTemplates).command(v2PrismaV7Prep).command("redwood", "List or run Redwood codemods", (yargs2) => {
+import * as v3PrismaV7 from "./codemods/v3.x/prismaV7/prismaV7.yargs.js";
+yargs(hideBin(process.argv)).scriptName("").command(v2MoveGeneratorTemplates).command(v2PrismaV7Prep).command(v3PrismaV7).command("redwood", "List or run Redwood codemods", (yargs2) => {
   return yargs2.command(v2TsconfigForRouteHooks).command(v2ConfigureFastify).command(v2UpdateResolverTypes).command(v4UpdateClerkGetCurrentUser).command(v4UseArmor).command(v5CellQueryResult).command(v5DetectEmptyCells).command(v5RenameValidateWith).command(v5UpdateAuth0ToV2).command(v5UpdateNodeEngineTo18).command(v5UpgradeToReact18).command(v6GlobalThis).command(v6Jsx).command(v6EntryClient).command(v6EnvDot).command(v6Svgs).command(v6DevFatalErrorPage).command(v6ThemeConfig).command(v7Gql).demandCommand().strict();
 }).demandCommand().epilog(
   [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/codemods",
-  "version": "3.0.0-canary.13607+f190aacd5",
+  "version": "3.0.0-canary.13610+e4c07ee8e",
   "description": "Codemods to ease upgrading a CedarJS Project",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
     "@babel/plugin-transform-typescript": "^7.26.8",
     "@babel/runtime-corejs3": "7.29.0",
     "@babel/traverse": "7.29.0",
-    "@cedarjs/project-config": "3.0.0-canary.13607",
+    "@cedarjs/project-config": "3.0.0-canary.13610",
     "@svgr/core": "8.1.0",
     "@svgr/plugin-jsx": "8.1.0",
     "@vscode/ripgrep": "1.17.1",
@@ -49,7 +49,7 @@
     "yargs": "17.7.2"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "3.0.0-canary.13607",
+    "@cedarjs/framework-tools": "3.0.0-canary.13610",
     "@types/babel__core": "7.20.5",
     "@types/jscodeshift": "17.3.0",
     "@types/yargs": "17.0.35",
@@ -62,5 +62,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f190aacd5629d47e68cbdc21188ee855d855bab9"
+  "gitHead": "e4c07ee8e478f9a417c260eb8bf5366a869a4d49"
 }