create-better-t-stack 3.7.3-canary.7cbb05fc → 3.7.3-canary.8e4d5716

package/src/helpers/core/db-setup.ts

@@ -0,0 +1,184 @@
+import path from "node:path";
+import consola from "consola";
+import fs from "fs-extra";
+import pc from "picocolors";
+import type { AvailableDependencies } from "../../constants";
+import type { ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+import { setupCloudflareD1 } from "../database-providers/d1-setup";
+import { setupDockerCompose } from "../database-providers/docker-compose-setup";
+import { setupMongoDBAtlas } from "../database-providers/mongodb-atlas-setup";
+import { setupNeonPostgres } from "../database-providers/neon-setup";
+import { setupPlanetScale } from "../database-providers/planetscale-setup";
+import { setupPrismaPostgres } from "../database-providers/prisma-postgres-setup";
+import { setupSupabase } from "../database-providers/supabase-setup";
+import { setupTurso } from "../database-providers/turso-setup";
+
+export async function setupDatabase(config: ProjectConfig, cliInput?: { manualDb?: boolean }) {
+  const { database, orm, dbSetup, backend, projectDir } = config;
+
+  if (backend === "convex" || database === "none") {
+    if (backend !== "convex") {
+      const serverDir = path.join(projectDir, "apps/server");
+      const serverDbDir = path.join(serverDir, "src/db");
+      if (await fs.pathExists(serverDbDir)) {
+        await fs.remove(serverDbDir);
+      }
+    }
+    return;
+  }
+
+  const dbPackageDir = path.join(projectDir, "packages/db");
+  const webDir = path.join(projectDir, "apps/web");
+  const webDirExists = await fs.pathExists(webDir);
+
+  if (!(await fs.pathExists(dbPackageDir))) {
+    return;
+  }
+
+  try {
+    if (orm === "prisma") {
+      if (database === "mongodb") {
+        await addPackageDependency({
+          customDependencies: {
+            "@prisma/client": "6.19.0",
+          },
+          customDevDependencies: {
+            prisma: "6.19.0",
+          },
+          projectDir: dbPackageDir,
+        });
+      } else {
+        const prismaDependencies: AvailableDependencies[] = ["@prisma/client"];
+        const prismaDevDependencies: AvailableDependencies[] = ["prisma"];
+
+        if (database === "mysql" && dbSetup === "planetscale") {
+          prismaDependencies.push("@prisma/adapter-planetscale", "@planetscale/database");
+        } else if (database === "mysql") {
+          prismaDependencies.push("@prisma/adapter-mariadb");
+        } else if (database === "sqlite") {
+          if (dbSetup === "d1") {
+            prismaDependencies.push("@prisma/adapter-d1");
+          } else {
+            prismaDependencies.push("@prisma/adapter-libsql");
+          }
+        } else if (database === "postgres") {
+          if (dbSetup === "neon") {
+            prismaDependencies.push("@prisma/adapter-neon", "@neondatabase/serverless", "ws");
+            prismaDevDependencies.push("@types/ws");
+          } else if (dbSetup === "prisma-postgres") {
+            prismaDependencies.push("@prisma/adapter-pg");
+          } else {
+            prismaDependencies.push("@prisma/adapter-pg");
+            prismaDependencies.push("pg");
+            prismaDevDependencies.push("@types/pg");
+          }
+        }
+
+        await addPackageDependency({
+          dependencies: prismaDependencies,
+          devDependencies: prismaDevDependencies,
+          projectDir: dbPackageDir,
+        });
+      }
+
+      if (await fs.pathExists(webDir)) {
+        if (database === "mongodb") {
+          await addPackageDependency({
+            customDependencies: {
+              "@prisma/client": "6.19.0",
+            },
+            projectDir: webDir,
+          });
+        } else {
+          await addPackageDependency({
+            dependencies: ["@prisma/client"],
+            projectDir: webDir,
+          });
+        }
+      }
+    } else if (orm === "drizzle") {
+      if (database === "sqlite") {
+        await addPackageDependency({
+          dependencies: ["drizzle-orm", "@libsql/client", "libsql"],
+          devDependencies: ["drizzle-kit"],
+          projectDir: dbPackageDir,
+        });
+        if (webDirExists) {
+          await addPackageDependency({
+            dependencies: ["@libsql/client", "libsql"],
+            projectDir: webDir,
+          });
+        }
+      } else if (database === "postgres") {
+        if (dbSetup === "neon") {
+          await addPackageDependency({
+            dependencies: ["drizzle-orm", "@neondatabase/serverless", "ws"],
+            devDependencies: ["drizzle-kit", "@types/ws"],
+            projectDir: dbPackageDir,
+          });
+        } else if (dbSetup === "planetscale") {
+          await addPackageDependency({
+            dependencies: ["drizzle-orm", "pg"],
+            devDependencies: ["drizzle-kit", "@types/pg"],
+            projectDir: dbPackageDir,
+          });
+        } else {
+          await addPackageDependency({
+            dependencies: ["drizzle-orm", "pg"],
+            devDependencies: ["drizzle-kit", "@types/pg"],
+            projectDir: dbPackageDir,
+          });
+        }
+      } else if (database === "mysql") {
+        if (dbSetup === "planetscale") {
+          await addPackageDependency({
+            dependencies: ["drizzle-orm", "@planetscale/database"],
+            devDependencies: ["drizzle-kit"],
+            projectDir: dbPackageDir,
+          });
+        } else {
+          await addPackageDependency({
+            dependencies: ["drizzle-orm", "mysql2"],
+            devDependencies: ["drizzle-kit"],
+            projectDir: dbPackageDir,
+          });
+        }
+      }
+    } else if (orm === "mongoose") {
+      await addPackageDependency({
+        dependencies: ["mongoose"],
+        devDependencies: [],
+        projectDir: dbPackageDir,
+      });
+    }
+
+    if (dbSetup === "docker") {
+      await setupDockerCompose(config);
+    } else if (database === "sqlite" && dbSetup === "turso") {
+      await setupTurso(config, cliInput);
+    } else if (database === "sqlite" && dbSetup === "d1") {
+      await setupCloudflareD1(config);
+    } else if (database === "postgres") {
+      if (dbSetup === "prisma-postgres") {
+        await setupPrismaPostgres(config, cliInput);
+      } else if (dbSetup === "neon") {
+        await setupNeonPostgres(config, cliInput);
+      } else if (dbSetup === "planetscale") {
+        await setupPlanetScale(config);
+      } else if (dbSetup === "supabase") {
+        await setupSupabase(config, cliInput);
+      }
+    } else if (database === "mysql") {
+      if (dbSetup === "planetscale") {
+        await setupPlanetScale(config);
+      }
+    } else if (database === "mongodb" && dbSetup === "mongodb-atlas") {
+      await setupMongoDBAtlas(config, cliInput);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      consola.error(pc.red(error.message));
+    }
+  }
+}

package/src/helpers/core/detect-project-config.ts

@@ -0,0 +1,41 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { readBtsConfig } from "../../utils/bts-config";
+
+export async function detectProjectConfig(projectDir: string) {
+  try {
+    const btsConfig = await readBtsConfig(projectDir);
+    if (btsConfig) {
+      return {
+        projectDir,
+        projectName: path.basename(projectDir),
+        database: btsConfig.database,
+        orm: btsConfig.orm,
+        backend: btsConfig.backend,
+        runtime: btsConfig.runtime,
+        frontend: btsConfig.frontend,
+        addons: btsConfig.addons,
+        examples: btsConfig.examples,
+        auth: btsConfig.auth,
+        payments: btsConfig.payments,
+        packageManager: btsConfig.packageManager,
+        dbSetup: btsConfig.dbSetup,
+        api: btsConfig.api,
+        webDeploy: btsConfig.webDeploy,
+        serverDeploy: btsConfig.serverDeploy,
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function isBetterTStackProject(projectDir: string) {
+  try {
+    return await fs.pathExists(path.join(projectDir, "bts.jsonc"));
+  } catch {
+    return false;
+  }
+}

package/src/helpers/core/env-setup.ts

@@ -0,0 +1,449 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { ProjectConfig } from "../../types";
+import { generateAuthSecret } from "./auth-setup";
+
+function getClientServerVar(frontend: string[], backend: ProjectConfig["backend"]) {
+  const hasNextJs = frontend.includes("next");
+  const hasNuxt = frontend.includes("nuxt");
+  const hasSvelte = frontend.includes("svelte");
+  const hasTanstackStart = frontend.includes("tanstack-start");
+
+  // For fullstack self, no base URL is needed (same-origin)
+  if (backend === "self") {
+    return { key: "", value: "", write: false } as const;
+  }
+
+  let key = "VITE_SERVER_URL";
+  if (hasNextJs) key = "NEXT_PUBLIC_SERVER_URL";
+  else if (hasNuxt) key = "NUXT_PUBLIC_SERVER_URL";
+  else if (hasSvelte) key = "PUBLIC_SERVER_URL";
+  else if (hasTanstackStart) key = "VITE_SERVER_URL";
+
+  return { key, value: "http://localhost:3000", write: true } as const;
+}
+
+function getConvexVar(frontend: string[]) {
+  const hasNextJs = frontend.includes("next");
+  const hasNuxt = frontend.includes("nuxt");
+  const hasSvelte = frontend.includes("svelte");
+  const hasTanstackStart = frontend.includes("tanstack-start");
+  if (hasNextJs) return "NEXT_PUBLIC_CONVEX_URL";
+  if (hasNuxt) return "NUXT_PUBLIC_CONVEX_URL";
+  if (hasSvelte) return "PUBLIC_CONVEX_URL";
+  if (hasTanstackStart) return "VITE_CONVEX_URL";
+  return "VITE_CONVEX_URL";
+}
+
+export interface EnvVariable {
+  key: string;
+  value: string | null | undefined;
+  condition: boolean;
+  comment?: string;
+}
+
+export async function addEnvVariablesToFile(filePath: string, variables: EnvVariable[]) {
+  await fs.ensureDir(path.dirname(filePath));
+
+  let envContent = "";
+  if (await fs.pathExists(filePath)) {
+    envContent = await fs.readFile(filePath, "utf8");
+  }
+
+  let modified = false;
+  let contentToAdd = "";
+  const exampleVariables: string[] = [];
+
+  for (const { key, value, condition, comment } of variables) {
+    if (condition) {
+      const regex = new RegExp(`^${key}=.*$`, "m");
+      const valueToWrite = value ?? "";
+      exampleVariables.push(`${key}=`);
+
+      if (regex.test(envContent)) {
+        const existingMatch = envContent.match(regex);
+        if (existingMatch && existingMatch[0] !== `${key}=${valueToWrite}`) {
+          envContent = envContent.replace(regex, `${key}=${valueToWrite}`);
+          modified = true;
+        }
+      } else {
+        if (comment) {
+          contentToAdd += `# ${comment}\n`;
+        }
+        contentToAdd += `${key}=${valueToWrite}\n`;
+        modified = true;
+      }
+    }
+  }
+
+  if (contentToAdd) {
+    if (envContent.length > 0 && !envContent.endsWith("\n")) {
+      envContent += "\n";
+    }
+    envContent += contentToAdd;
+  }
+
+  if (modified) {
+    await fs.writeFile(filePath, envContent.trimEnd());
+  }
+
+  const exampleFilePath = filePath.replace(/\.env$/, ".env.example");
+  let exampleEnvContent = "";
+  if (await fs.pathExists(exampleFilePath)) {
+    exampleEnvContent = await fs.readFile(exampleFilePath, "utf8");
+  }
+
+  let exampleModified = false;
+  let exampleContentToAdd = "";
+
+  for (const exampleVar of exampleVariables) {
+    const key = exampleVar.split("=")[0];
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (!regex.test(exampleEnvContent)) {
+      exampleContentToAdd += `${exampleVar}\n`;
+      exampleModified = true;
+    }
+  }
+
+  if (exampleContentToAdd) {
+    if (exampleEnvContent.length > 0 && !exampleEnvContent.endsWith("\n")) {
+      exampleEnvContent += "\n";
+    }
+    exampleEnvContent += exampleContentToAdd;
+  }
+
+  if (exampleModified || !(await fs.pathExists(exampleFilePath))) {
+    await fs.writeFile(exampleFilePath, exampleEnvContent.trimEnd());
+  }
+}
+
+export async function setupEnvironmentVariables(config: ProjectConfig) {
+  const {
+    backend,
+    frontend,
+    database,
+    auth,
+    examples,
+    dbSetup,
+    projectDir,
+    webDeploy,
+    serverDeploy,
+  } = config;
+
+  const hasReactRouter = frontend.includes("react-router");
+  const hasTanStackRouter = frontend.includes("tanstack-router");
+  const hasTanStackStart = frontend.includes("tanstack-start");
+  const hasNextJs = frontend.includes("next");
+  const hasNuxt = frontend.includes("nuxt");
+  const hasSvelte = frontend.includes("svelte");
+  const hasSolid = frontend.includes("solid");
+  const hasWebFrontend =
+    hasReactRouter ||
+    hasTanStackRouter ||
+    hasTanStackStart ||
+    hasNextJs ||
+    hasNuxt ||
+    hasSolid ||
+    hasSvelte;
+
+  if (hasWebFrontend) {
+    const clientDir = path.join(projectDir, "apps/web");
+    if (await fs.pathExists(clientDir)) {
+      const baseVar = getClientServerVar(frontend, backend);
+      const envVarName = backend === "convex" ? getConvexVar(frontend) : baseVar.key;
+      const serverUrl = backend === "convex" ? "https://<YOUR_CONVEX_URL>" : baseVar.value;
+
+      const clientVars: EnvVariable[] = [
+        {
+          key: envVarName,
+          value: serverUrl,
+          condition: backend === "convex" ? true : baseVar.write,
+        },
+      ];
+
+      if (backend === "convex" && auth === "clerk") {
+        if (hasNextJs) {
+          clientVars.push(
+            {
+              key: "NEXT_PUBLIC_CLERK_FRONTEND_API_URL",
+              value: "",
+              condition: true,
+            },
+            {
+              key: "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY",
+              value: "",
+              condition: true,
+            },
+            {
+              key: "CLERK_SECRET_KEY",
+              value: "",
+              condition: true,
+            },
+          );
+        } else if (hasReactRouter || hasTanStackRouter || hasTanStackStart) {
+          clientVars.push({
+            key: "VITE_CLERK_PUBLISHABLE_KEY",
+            value: "",
+            condition: true,
+          });
+          if (hasTanStackStart) {
+            clientVars.push({
+              key: "CLERK_SECRET_KEY",
+              value: "",
+              condition: true,
+            });
+          }
+        }
+      }
+
+      if (backend === "convex" && auth === "better-auth") {
+        if (hasNextJs) {
+          clientVars.push({
+            key: "NEXT_PUBLIC_CONVEX_SITE_URL",
+            value: "https://<YOUR_CONVEX_URL>",
+            condition: true,
+          });
+        } else if (hasReactRouter || hasTanStackRouter || hasTanStackStart) {
+          clientVars.push({
+            key: "VITE_CONVEX_SITE_URL",
+            value: "https://<YOUR_CONVEX_URL>",
+            condition: true,
+          });
+        }
+      }
+
+      await addEnvVariablesToFile(path.join(clientDir, ".env"), clientVars);
+    }
+  }
+
+  if (
+    frontend.includes("native-bare") ||
+    frontend.includes("native-uniwind") ||
+    frontend.includes("native-unistyles")
+  ) {
+    const nativeDir = path.join(projectDir, "apps/native");
+    if (await fs.pathExists(nativeDir)) {
+      let envVarName = "EXPO_PUBLIC_SERVER_URL";
+      let serverUrl = "http://localhost:3000";
+
+      if (backend === "self") {
+        // Both TanStack Start and Next.js use port 3001 for fullstack
+        serverUrl = "http://localhost:3001";
+      }
+
+      if (backend === "convex") {
+        envVarName = "EXPO_PUBLIC_CONVEX_URL";
+        serverUrl = "https://<YOUR_CONVEX_URL>";
+      }
+
+      const nativeVars: EnvVariable[] = [
+        {
+          key: envVarName,
+          value: serverUrl,
+          condition: true,
+        },
+      ];
+
+      if (backend === "convex" && auth === "clerk") {
+        nativeVars.push({
+          key: "EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY",
+          value: "",
+          condition: true,
+        });
+      }
+
+      if (backend === "convex" && auth === "better-auth") {
+        nativeVars.push({
+          key: "EXPO_PUBLIC_CONVEX_SITE_URL",
+          value: "https://<YOUR_CONVEX_URL>",
+          condition: true,
+        });
+      }
+      await addEnvVariablesToFile(path.join(nativeDir, ".env"), nativeVars);
+    }
+  }
+
+  if (backend === "convex") {
+    if (auth === "better-auth") {
+      const convexBackendDir = path.join(projectDir, "packages/backend");
+      if (await fs.pathExists(convexBackendDir)) {
+        const envLocalPath = path.join(convexBackendDir, ".env.local");
+
+        const hasNative =
+          frontend.includes("native-bare") ||
+          frontend.includes("native-uniwind") ||
+          frontend.includes("native-unistyles");
+        const hasWeb = hasWebFrontend;
+
+        if (
+          !(await fs.pathExists(envLocalPath)) ||
+          !(await fs.readFile(envLocalPath, "utf8")).includes("npx convex env set")
+        ) {
+          const convexCommands = `# Set Convex environment variables
+# npx convex env set BETTER_AUTH_SECRET=$(openssl rand -base64 32)
+${hasWeb ? "# npx convex env set SITE_URL http://localhost:3001\n" : ""}
+`;
+          await fs.appendFile(envLocalPath, convexCommands);
+        }
+
+        const convexBackendVars: EnvVariable[] = [];
+
+        if (hasNative) {
+          convexBackendVars.push({
+            key: "EXPO_PUBLIC_CONVEX_SITE_URL",
+            value: "",
+            condition: true,
+            comment: "Same as CONVEX_URL but ends in .site",
+          });
+        }
+
+        if (hasWeb) {
+          convexBackendVars.push(
+            {
+              key: hasNextJs ? "NEXT_PUBLIC_CONVEX_SITE_URL" : "VITE_CONVEX_SITE_URL",
+              value: "",
+              condition: true,
+              comment: "Same as CONVEX_URL but ends in .site",
+            },
+            {
+              key: "SITE_URL",
+              value: "http://localhost:3001",
+              condition: true,
+            },
+          );
+        }
+
+        await addEnvVariablesToFile(envLocalPath, convexBackendVars);
+      }
+    }
+    return;
+  }
+
+  const serverDir = path.join(projectDir, "apps/server");
+
+  let corsOrigin = "http://localhost:3001";
+  if (backend === "self") {
+    corsOrigin = "http://localhost:3001";
+  } else if (hasReactRouter || hasSvelte) {
+    corsOrigin = "http://localhost:5173";
+  }
+
+  let databaseUrl: string | null = null;
+
+  if (database !== "none" && dbSetup === "none") {
+    switch (database) {
+      case "postgres":
+        databaseUrl = "postgresql://postgres:password@localhost:5432/postgres";
+        break;
+      case "mysql":
+        databaseUrl = "mysql://root:password@localhost:3306/mydb";
+        break;
+      case "mongodb":
+        databaseUrl = "mongodb://localhost:27017/mydatabase";
+        break;
+      case "sqlite":
+        if (config.runtime === "workers" || webDeploy === "alchemy" || serverDeploy === "alchemy") {
+          databaseUrl = "http://127.0.0.1:8080";
+        } else {
+          const dbAppDir = backend === "self" ? "apps/web" : "apps/server";
+          databaseUrl = `file:${path.join(config.projectDir, dbAppDir, "local.db")}`;
+        }
+        break;
+    }
+  }
+
+  const serverVars: EnvVariable[] = [
+    {
+      key: "BETTER_AUTH_SECRET",
+      value: generateAuthSecret(),
+      condition: !!auth,
+    },
+    {
+      key: "BETTER_AUTH_URL",
+      value: backend === "self" ? "http://localhost:3001" : "http://localhost:3000",
+      condition: !!auth,
+    },
+    {
+      key: "POLAR_ACCESS_TOKEN",
+      value: "",
+      condition: config.payments === "polar",
+    },
+    {
+      key: "POLAR_SUCCESS_URL",
+      value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
+      condition: config.payments === "polar",
+    },
+    {
+      key: "CORS_ORIGIN",
+      value: corsOrigin,
+      condition: true,
+    },
+    {
+      key: "GOOGLE_GENERATIVE_AI_API_KEY",
+      value: "",
+      condition: examples?.includes("ai") || false,
+    },
+    {
+      key: "DATABASE_URL",
+      value: databaseUrl,
+      condition: database !== "none" && dbSetup === "none",
+    },
+  ];
+
+  if (backend === "self") {
+    const webDir = path.join(projectDir, "apps/web");
+    if (await fs.pathExists(webDir)) {
+      await addEnvVariablesToFile(path.join(webDir, ".env"), serverVars);
+    }
+  } else if (await fs.pathExists(serverDir)) {
+    await addEnvVariablesToFile(path.join(serverDir, ".env"), serverVars);
+  }
+
+  const isUnifiedAlchemy = webDeploy === "alchemy" && serverDeploy === "alchemy";
+  const isIndividualAlchemy = webDeploy === "alchemy" || serverDeploy === "alchemy";
+
+  if (isUnifiedAlchemy) {
+    const rootEnvPath = path.join(projectDir, ".env");
+    const rootAlchemyVars: EnvVariable[] = [
+      {
+        key: "ALCHEMY_PASSWORD",
+        value: "please-change-this",
+        condition: true,
+      },
+    ];
+    await addEnvVariablesToFile(rootEnvPath, rootAlchemyVars);
+  } else if (isIndividualAlchemy) {
+    if (webDeploy === "alchemy") {
+      const webDir = path.join(projectDir, "apps/web");
+      if (await fs.pathExists(webDir)) {
+        const webAlchemyVars: EnvVariable[] = [
+          {
+            key: "ALCHEMY_PASSWORD",
+            value: "please-change-this",
+            condition: true,
+          },
+        ];
+        await addEnvVariablesToFile(path.join(webDir, ".env"), webAlchemyVars);
+      }
+    }
+
+    if (serverDeploy === "alchemy") {
+      const serverAlchemyVars: EnvVariable[] = [
+        {
+          key: "ALCHEMY_PASSWORD",
+          value: "please-change-this",
+          condition: true,
+        },
+      ];
+
+      if (backend === "self") {
+        const webDir = path.join(projectDir, "apps/web");
+        if (await fs.pathExists(webDir)) {
+          await addEnvVariablesToFile(path.join(webDir, ".env"), serverAlchemyVars);
+        }
+      } else {
+        await addEnvVariablesToFile(path.join(serverDir, ".env"), serverAlchemyVars);
+      }
+    }
+  }
+}

package/src/helpers/core/git.ts

@@ -0,0 +1,31 @@
+import { log } from "@clack/prompts";
+import { $ } from "execa";
+import pc from "picocolors";
+
+export async function initializeGit(projectDir: string, useGit: boolean) {
+  if (!useGit) return;
+
+  const gitVersionResult = await $({
+    cwd: projectDir,
+    reject: false,
+    stderr: "pipe",
+  })`git --version`;
+
+  if (gitVersionResult.exitCode !== 0) {
+    log.warn(pc.yellow("Git is not installed"));
+    return;
+  }
+
+  const result = await $({
+    cwd: projectDir,
+    reject: false,
+    stderr: "pipe",
+  })`git init`;
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Git initialization failed: ${result.stderr}`);
+  }
+
+  await $({ cwd: projectDir })`git add -A`;
+  await $({ cwd: projectDir })`git commit -m ${"initial commit"}`;
+}