create-better-t-stack 3.7.3-canary.8e4d5716 → 3.7.3-canary.98ba1e7a

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

@@ -1,184 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import type { AvailableDependencies } from "../../constants";
-import type { ProjectConfig } from "../../types";
-import { addPackageDependency } from "../../utils/add-package-deps";
-
-export async function setupWorkspaceDependencies(projectDir: string, options: ProjectConfig) {
-  const { projectName, packageManager, database, auth, api, runtime, backend } = options;
-  const workspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
-
-  const commonDeps: AvailableDependencies[] = ["dotenv", "zod"];
-  const commonDevDeps: AvailableDependencies[] = ["typescript"];
-
-  const configDir = path.join(projectDir, "packages/config");
-  const dbDir = path.join(projectDir, "packages/db");
-  const authDir = path.join(projectDir, "packages/auth");
-  const apiDir = path.join(projectDir, "packages/api");
-  const backendDir = path.join(projectDir, "packages/backend");
-  const serverDir = path.join(projectDir, "apps/server");
-  const webDir = path.join(projectDir, "apps/web");
-  const nativeDir = path.join(projectDir, "apps/native");
-
-  const [
-    configExists,
-    dbExists,
-    authExists,
-    apiExists,
-    backendExists,
-    serverExists,
-    webExists,
-    nativeExists,
-  ] = await Promise.all([
-    fs.pathExists(configDir),
-    fs.pathExists(dbDir),
-    fs.pathExists(authDir),
-    fs.pathExists(apiDir),
-    fs.pathExists(backendDir),
-    fs.pathExists(serverDir),
-    fs.pathExists(webDir),
-    fs.pathExists(nativeDir),
-  ]);
-
-  const configDep: Record<string, string> = configExists
-    ? { [`@${projectName}/config`]: workspaceVersion }
-    : {};
-
-  if (dbExists) {
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: commonDevDeps,
-      customDevDependencies: configDep,
-      projectDir: dbDir,
-    });
-  }
-
-  if (authExists) {
-    const authDeps: Record<string, string> = {};
-    if (database !== "none" && dbExists) {
-      authDeps[`@${projectName}/db`] = workspaceVersion;
-    }
-
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: commonDevDeps,
-      customDependencies: authDeps,
-      customDevDependencies: configDep,
-      projectDir: authDir,
-    });
-  }
-
-  if (apiExists) {
-    const apiDeps: Record<string, string> = {};
-    if (auth !== "none" && authExists) {
-      apiDeps[`@${projectName}/auth`] = workspaceVersion;
-    }
-    if (database !== "none" && dbExists) {
-      apiDeps[`@${projectName}/db`] = workspaceVersion;
-    }
-
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: commonDevDeps,
-      customDependencies: apiDeps,
-      customDevDependencies: configDep,
-      projectDir: apiDir,
-    });
-  }
-
-  if (backendExists) {
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: commonDevDeps,
-      customDevDependencies: configDep,
-      projectDir: backendDir,
-    });
-  }
-
-  if (serverExists) {
-    const serverDeps: Record<string, string> = {};
-    if (api !== "none" && apiExists) {
-      serverDeps[`@${projectName}/api`] = workspaceVersion;
-    }
-    if (auth !== "none" && authExists) {
-      serverDeps[`@${projectName}/auth`] = workspaceVersion;
-    }
-    if (database !== "none" && dbExists) {
-      serverDeps[`@${projectName}/db`] = workspaceVersion;
-    }
-
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: [...commonDevDeps, "tsdown"],
-      customDependencies: serverDeps,
-      customDevDependencies: configDep,
-      projectDir: serverDir,
-    });
-  }
-
-  if (webExists) {
-    const webDeps: Record<string, string> = {};
-    if (api !== "none" && apiExists) {
-      webDeps[`@${projectName}/api`] = workspaceVersion;
-    }
-    if (auth !== "none" && authExists) {
-      webDeps[`@${projectName}/auth`] = workspaceVersion;
-    }
-    if (backend === "convex" && backendExists) {
-      webDeps[`@${projectName}/backend`] = workspaceVersion;
-    }
-
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: commonDevDeps,
-      customDependencies: webDeps,
-      customDevDependencies: configDep,
-      projectDir: webDir,
-    });
-  }
-
-  if (nativeExists) {
-    const nativeDeps: Record<string, string> = {};
-    if (api !== "none" && apiExists) {
-      nativeDeps[`@${projectName}/api`] = workspaceVersion;
-    }
-    if (backend === "convex" && backendExists) {
-      nativeDeps[`@${projectName}/backend`] = workspaceVersion;
-    }
-
-    await addPackageDependency({
-      dependencies: commonDeps,
-      devDependencies: commonDevDeps,
-      customDependencies: nativeDeps,
-      customDevDependencies: configDep,
-      projectDir: nativeDir,
-    });
-  }
-
-  const runtimeDevDeps = getRuntimeDevDeps(runtime, backend);
-
-  await addPackageDependency({
-    dependencies: commonDeps,
-    devDependencies: [...commonDevDeps, ...runtimeDevDeps],
-    projectDir,
-  });
-}
-
-function getRuntimeDevDeps(
-  runtime: ProjectConfig["runtime"],
-  backend: ProjectConfig["backend"],
-): AvailableDependencies[] {
-  if (runtime === "none" && backend === "self") {
-    return ["@types/node"];
-  }
-
-  if (runtime === "node" || runtime === "workers") {
-    return ["@types/node"];
-  }
-
-  if (runtime === "bun") {
-    return ["@types/bun"];
-  }
-
-  return [];
-}

package/src/helpers/database-providers/d1-setup.ts

@@ -1,28 +0,0 @@
-import path from "node:path";
-import type { ProjectConfig } from "../../types";
-import { addPackageDependency } from "../../utils/add-package-deps";
-import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
-
-export async function setupCloudflareD1(config: ProjectConfig) {
-  const { projectDir, serverDeploy, orm, backend } = config;
-
-  if (serverDeploy === "alchemy" && orm === "prisma") {
-    const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
-    const envPath = path.join(projectDir, targetApp2, ".env");
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: `file:${path.join(projectDir, "apps/server", "local.db")}`,
-        condition: true,
-      },
-    ];
-
-    await addEnvVariablesToFile(envPath, variables);
-
-    const serverDir = path.join(projectDir, backend === "self" ? "apps/web" : "apps/server");
-    await addPackageDependency({
-      dependencies: ["@prisma/adapter-d1"],
-      projectDir: serverDir,
-    });
-  }
-}

package/src/helpers/database-providers/docker-compose-setup.ts

@@ -1,50 +0,0 @@
-import path from "node:path";
-import type { Database, ProjectConfig } from "../../types";
-import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
-
-export async function setupDockerCompose(config: ProjectConfig) {
-  const { database, projectDir, projectName, backend } = config;
-
-  if (database === "none" || database === "sqlite") {
-    return;
-  }
-
-  try {
-    await writeEnvFile(projectDir, database, projectName, backend);
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(`Error: ${error.message}`);
-    }
-  }
-}
-
-async function writeEnvFile(
-  projectDir: string,
-  database: Database,
-  projectName: string,
-  backend?: string,
-) {
-  const targetApp = backend === "self" ? "apps/web" : "apps/server";
-  const envPath = path.join(projectDir, targetApp, ".env");
-  const variables: EnvVariable[] = [
-    {
-      key: "DATABASE_URL",
-      value: getDatabaseUrl(database, projectName),
-      condition: true,
-    },
-  ];
-  await addEnvVariablesToFile(envPath, variables);
-}
-
-function getDatabaseUrl(database: Database, projectName: string) {
-  switch (database) {
-    case "postgres":
-      return `postgresql://postgres:password@localhost:5432/${projectName}`;
-    case "mysql":
-      return `mysql://user:password@localhost:3306/${projectName}`;
-    case "mongodb":
-      return `mongodb://root:password@localhost:27017/${projectName}?authSource=admin`;
-    default:
-      return "";
-  }
-}

package/src/helpers/database-providers/mongodb-atlas-setup.ts

@@ -1,186 +0,0 @@
-import path from "node:path";
-import { cancel, isCancel, log, select, text } from "@clack/prompts";
-import consola from "consola";
-import { execa } from "execa";
-import fs from "fs-extra";
-import pc from "picocolors";
-import type { ProjectConfig } from "../../types";
-import { commandExists } from "../../utils/command-exists";
-import { exitCancelled } from "../../utils/errors";
-import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
-
-type MongoDBConfig = {
-  connectionString: string;
-};
-
-async function checkAtlasCLI() {
-  try {
-    const exists = await commandExists("atlas");
-    if (exists) {
-      log.info("MongoDB Atlas CLI found");
-    } else {
-      log.warn(pc.yellow("MongoDB Atlas CLI not found"));
-    }
-    return exists;
-  } catch {
-    log.error(pc.red("Error checking MongoDB Atlas CLI"));
-    return false;
-  }
-}
-
-async function initMongoDBAtlas(serverDir: string) {
-  try {
-    const hasAtlas = await checkAtlasCLI();
-
-    if (!hasAtlas) {
-      consola.error(pc.red("MongoDB Atlas CLI not found."));
-      log.info(
-        pc.yellow(
-          "Please install it from: https://www.mongodb.com/docs/atlas/cli/current/install-atlas-cli/",
-        ),
-      );
-      return null;
-    }
-
-    log.info("Running MongoDB Atlas setup...");
-
-    await execa("atlas", ["deployments", "setup"], {
-      cwd: serverDir,
-      shell: true,
-      stdio: "inherit",
-    });
-
-    log.success("MongoDB Atlas deployment ready");
-
-    const connectionString = await text({
-      message: "Enter your MongoDB connection string:",
-      placeholder: "mongodb+srv://username:password@cluster.mongodb.net/database",
-      validate(value) {
-        if (!value) return "Please enter a connection string";
-        if (!value.startsWith("mongodb")) {
-          return "URL should start with mongodb:// or mongodb+srv://";
-        }
-      },
-    });
-
-    if (isCancel(connectionString)) {
-      cancel("MongoDB setup cancelled");
-      return null;
-    }
-
-    return {
-      connectionString: connectionString as string,
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      consola.error(pc.red(error.message));
-    }
-    return null;
-  }
-}
-
-async function writeEnvFile(
-  projectDir: string,
-  backend: ProjectConfig["backend"],
-  config?: MongoDBConfig,
-) {
-  try {
-    const targetApp = backend === "self" ? "apps/web" : "apps/server";
-    const envPath = path.join(projectDir, targetApp, ".env");
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: config?.connectionString ?? "mongodb://localhost:27017/mydb",
-        condition: true,
-      },
-    ];
-    await addEnvVariablesToFile(envPath, variables);
-  } catch {
-    consola.error("Failed to update environment configuration");
-  }
-}
-
-function displayManualSetupInstructions() {
-  log.info(`
-${pc.green("MongoDB Atlas Manual Setup Instructions:")}
-
-1. Install Atlas CLI:
-   ${pc.blue("https://www.mongodb.com/docs/atlas/cli/stable/install-atlas-cli/")}
-
-2. Run the following command and follow the prompts:
-   ${pc.blue("atlas deployments setup")}
-
-3. Get your connection string from the Atlas dashboard:
-   Format: ${pc.dim("mongodb+srv://USERNAME:PASSWORD@CLUSTER.mongodb.net/DATABASE_NAME")}
-
-4. Add the connection string to your .env file:
-   ${pc.dim('DATABASE_URL="your_connection_string"')}
-`);
-}
-
-export async function setupMongoDBAtlas(config: ProjectConfig, cliInput?: { manualDb?: boolean }) {
-  const { projectDir, backend } = config;
-  const manualDb = cliInput?.manualDb ?? false;
-
-  const serverDir = path.join(projectDir, "packages/db");
-  try {
-    await fs.ensureDir(serverDir);
-
-    if (manualDb) {
-      log.info("MongoDB Atlas manual setup selected");
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions();
-      return;
-    }
-
-    const mode = await select({
-      message: "MongoDB Atlas setup: choose mode",
-      options: [
-        {
-          label: "Automatic",
-          value: "auto",
-          hint: "Automated setup with provider CLI, sets .env",
-        },
-        {
-          label: "Manual",
-          value: "manual",
-          hint: "Manual setup, add env vars yourself",
-        },
-      ],
-      initialValue: "auto",
-    });
-
-    if (isCancel(mode)) return exitCancelled("Operation cancelled");
-
-    if (mode === "manual") {
-      log.info("MongoDB Atlas manual setup selected");
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions();
-      return;
-    }
-
-    const config = await initMongoDBAtlas(serverDir);
-
-    if (config) {
-      await writeEnvFile(projectDir, backend, config);
-      log.success(pc.green("MongoDB Atlas setup complete! Connection saved to .env file."));
-    } else {
-      log.warn(pc.yellow("Falling back to local MongoDB configuration"));
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions();
-    }
-  } catch (error) {
-    consola.error(
-      pc.red(
-        `Error during MongoDB Atlas setup: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      ),
-    );
-
-    try {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions();
-    } catch {}
-  }
-}

package/src/helpers/database-providers/neon-setup.ts

@@ -1,243 +0,0 @@
-import path from "node:path";
-import { isCancel, log, select, spinner, text } from "@clack/prompts";
-import { consola } from "consola";
-import { execa } from "execa";
-import fs from "fs-extra";
-import pc from "picocolors";
-import type { PackageManager, ProjectConfig } from "../../types";
-import { exitCancelled } from "../../utils/errors";
-import { getPackageExecutionCommand } from "../../utils/package-runner";
-import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
-
-type NeonConfig = {
-  connectionString: string;
-  projectId: string;
-  dbName: string;
-  roleName: string;
-};
-
-type NeonRegion = {
-  label: string;
-  value: string;
-};
-
-const NEON_REGIONS: NeonRegion[] = [
-  { label: "AWS US East (N. Virginia)", value: "aws-us-east-1" },
-  { label: "AWS US East (Ohio)", value: "aws-us-east-2" },
-  { label: "AWS US West (Oregon)", value: "aws-us-west-2" },
-  { label: "AWS Europe (Frankfurt)", value: "aws-eu-central-1" },
-  { label: "AWS Asia Pacific (Singapore)", value: "aws-ap-southeast-1" },
-  { label: "AWS South America East 1 (São Paulo)", value: "aws-sa-east-1" },
-  { label: "AWS Asia Pacific (Sydney)", value: "aws-ap-southeast-2" },
-  { label: "Azure East US 2 region (Virginia)", value: "azure-eastus2" },
-];
-
-async function executeNeonCommand(
-  packageManager: PackageManager,
-  commandArgsString: string,
-  spinnerText?: string,
-) {
-  const s = spinner();
-  try {
-    const fullCommand = getPackageExecutionCommand(packageManager, commandArgsString);
-
-    if (spinnerText) s.start(spinnerText);
-    const result = await execa(fullCommand, { shell: true });
-    if (spinnerText) s.stop(pc.green(spinnerText.replace("...", "").replace("ing ", "ed ").trim()));
-    return result;
-  } catch (error) {
-    if (s) s.stop(pc.red(`Failed: ${spinnerText || "Command execution"}`));
-    throw error;
-  }
-}
-
-async function createNeonProject(
-  projectName: string,
-  regionId: string,
-  packageManager: PackageManager,
-) {
-  try {
-    const commandArgsString = `neonctl@latest projects create --name ${projectName} --region-id ${regionId} --output json`;
-    const { stdout } = await executeNeonCommand(
-      packageManager,
-      commandArgsString,
-      `Creating Neon project "${projectName}"...`,
-    );
-
-    const response = JSON.parse(stdout);
-
-    if (response.project && response.connection_uris && response.connection_uris.length > 0) {
-      const projectId = response.project.id;
-      const connectionUri = response.connection_uris[0].connection_uri;
-      const params = response.connection_uris[0].connection_parameters;
-
-      return {
-        connectionString: connectionUri,
-        projectId: projectId,
-        dbName: params.database,
-        roleName: params.role,
-      };
-    }
-    consola.error(pc.red("Failed to extract connection information from response"));
-    return null;
-  } catch {
-    consola.error(pc.red("Failed to create Neon project"));
-  }
-}
-
-async function writeEnvFile(
-  projectDir: string,
-  backend: ProjectConfig["backend"],
-  config?: NeonConfig,
-) {
-  const targetApp = backend === "self" ? "apps/web" : "apps/server";
-  const envPath = path.join(projectDir, targetApp, ".env");
-  const variables: EnvVariable[] = [
-    {
-      key: "DATABASE_URL",
-      value:
-        config?.connectionString ??
-        "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
-      condition: true,
-    },
-  ];
-  await addEnvVariablesToFile(envPath, variables);
-
-  return true;
-}
-
-async function setupWithNeonDb(
-  projectDir: string,
-  packageManager: PackageManager,
-  backend: ProjectConfig["backend"],
-) {
-  try {
-    const s = spinner();
-    s.start("Creating Neon database using get-db...");
-
-    const targetApp = backend === "self" ? "apps/web" : "apps/server";
-    const targetDir = path.join(projectDir, targetApp);
-    await fs.ensureDir(targetDir);
-
-    const packageCmd = getPackageExecutionCommand(packageManager, "get-db@latest --yes");
-
-    await execa(packageCmd, {
-      shell: true,
-      cwd: targetDir,
-    });
-
-    s.stop(pc.green("Neon database created successfully!"));
-
-    return true;
-  } catch (error) {
-    consola.error(pc.red("Failed to create database with get-db"));
-    throw error;
-  }
-}
-
-function displayManualSetupInstructions(target: "apps/web" | "apps/server") {
-  log.info(`Manual Neon PostgreSQL Setup Instructions:
-
-1. Visit https://neon.tech and create an account
-2. Create a new project from the dashboard
-3. Get your connection string
-4. Add the database URL to the .env file in ${target}/.env
-
-DATABASE_URL="your_connection_string"`);
-}
-
-export async function setupNeonPostgres(config: ProjectConfig, cliInput?: { manualDb?: boolean }) {
-  const { packageManager, projectDir, backend } = config;
-  const manualDb = cliInput?.manualDb ?? false;
-
-  try {
-    if (manualDb) {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-      return;
-    }
-
-    const mode = await select({
-      message: "Neon setup: choose mode",
-      options: [
-        {
-          label: "Automatic",
-          value: "auto",
-          hint: "Automated setup with provider CLI, sets .env",
-        },
-        {
-          label: "Manual",
-          value: "manual",
-          hint: "Manual setup, add env vars yourself",
-        },
-      ],
-      initialValue: "auto",
-    });
-
-    if (isCancel(mode)) return exitCancelled("Operation cancelled");
-
-    if (mode === "manual") {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-      return;
-    }
-
-    const setupMethod = await select({
-      message: "Choose your Neon setup method:",
-      options: [
-        {
-          label: "Quick setup with get-db",
-          value: "neondb",
-          hint: "fastest, no auth required",
-        },
-        {
-          label: "Custom setup with neonctl",
-          value: "neonctl",
-          hint: "More control - choose project name and region",
-        },
-      ],
-      initialValue: "neondb",
-    });
-
-    if (isCancel(setupMethod)) return exitCancelled("Operation cancelled");
-
-    if (setupMethod === "neondb") {
-      await setupWithNeonDb(projectDir, packageManager, backend);
-    } else {
-      const suggestedProjectName = path.basename(projectDir);
-      const projectName = await text({
-        message: "Enter a name for your Neon project:",
-        defaultValue: suggestedProjectName,
-        initialValue: suggestedProjectName,
-      });
-
-      const regionId = await select({
-        message: "Select a region for your Neon project:",
-        options: NEON_REGIONS,
-        initialValue: NEON_REGIONS[0].value,
-      });
-
-      if (isCancel(projectName) || isCancel(regionId)) return exitCancelled("Operation cancelled");
-
-      const neonConfig = await createNeonProject(projectName as string, regionId, packageManager);
-
-      if (!neonConfig) {
-        throw new Error("Failed to create project - couldn't get connection information");
-      }
-
-      const finalSpinner = spinner();
-      finalSpinner.start("Configuring database connection");
-
-      await writeEnvFile(projectDir, backend, neonConfig);
-
-      finalSpinner.stop("Neon database configured!");
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      consola.error(pc.red(error.message));
-    }
-
-    await writeEnvFile(projectDir, backend);
-    displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-  }
-}