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

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

@@ -1,78 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import type { ProjectConfig } from "../../types";
-import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
-
-export async function setupPlanetScale(config: ProjectConfig) {
-  const { projectDir, database, orm, backend } = config;
-
-  const targetApp = backend === "self" ? "apps/web" : "apps/server";
-  const envPath = path.join(projectDir, targetApp, ".env");
-
-  if (database === "mysql" && orm === "drizzle") {
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: 'mysql://username:password@host/database?ssl={"rejectUnauthorized":true}',
-        condition: true,
-      },
-      {
-        key: "DATABASE_HOST",
-        value: "",
-        condition: true,
-      },
-      {
-        key: "DATABASE_USERNAME",
-        value: "",
-        condition: true,
-      },
-      {
-        key: "DATABASE_PASSWORD",
-        value: "",
-        condition: true,
-      },
-    ];
-
-    await fs.ensureDir(path.join(projectDir, targetApp));
-    await addEnvVariablesToFile(envPath, variables);
-  }
-
-  if (database === "postgres" && orm === "prisma") {
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: "postgresql://username:password@host/database?sslaccept=strict",
-        condition: true,
-      },
-    ];
-
-    await fs.ensureDir(path.join(projectDir, targetApp));
-    await addEnvVariablesToFile(envPath, variables);
-  }
-
-  if (database === "postgres" && orm === "drizzle") {
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: "postgresql://username:password@host/database?sslmode=verify-full",
-        condition: true,
-      },
-    ];
-
-    await fs.ensureDir(path.join(projectDir, targetApp));
-    await addEnvVariablesToFile(envPath, variables);
-  }
-
-  if (database === "mysql" && orm === "prisma") {
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: "mysql://username:password@host/database?sslaccept=strict",
-        condition: true,
-      },
-    ];
-
-    await fs.ensureDir(path.join(projectDir, targetApp));
-    await addEnvVariablesToFile(envPath, variables);
-  }
-}

package/src/helpers/database-providers/prisma-postgres-setup.ts

@@ -1,196 +0,0 @@
-import path from "node:path";
-import { isCancel, log, select, spinner } 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 { getPackageExecutionCommand } from "../../utils/package-runner";
-import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
-
-type PrismaConfig = {
-  databaseUrl: string;
-  claimUrl?: string;
-};
-
-type CreateDbResponse = {
-  connectionString: string;
-  directConnectionString: string;
-  claimUrl: string;
-  deletionDate: string;
-  region: string;
-  name: string;
-  projectId: string;
-};
-
-const AVAILABLE_REGIONS = [
-  { value: "ap-southeast-1", label: "Asia Pacific (Singapore)" },
-  { value: "ap-northeast-1", label: "Asia Pacific (Tokyo)" },
-  { value: "eu-central-1", label: "Europe (Frankfurt)" },
-  { value: "eu-west-3", label: "Europe (Paris)" },
-  { value: "us-east-1", label: "US East (N. Virginia)" },
-  { value: "us-west-1", label: "US West (N. California)" },
-];
-
-async function setupWithCreateDb(serverDir: string, packageManager: PackageManager) {
-  try {
-    log.info("Starting Prisma Postgres setup with create-db.");
-
-    const selectedRegion = await select({
-      message: "Select your preferred region:",
-      options: AVAILABLE_REGIONS,
-      initialValue: "ap-southeast-1",
-    });
-
-    if (isCancel(selectedRegion)) return null;
-
-    const createDbCommand = getPackageExecutionCommand(
-      packageManager,
-      `create-db@latest --json --region ${selectedRegion}`,
-    );
-
-    const s = spinner();
-    s.start("Creating Prisma Postgres database...");
-
-    const { stdout } = await execa(createDbCommand, {
-      cwd: serverDir,
-      shell: true,
-    });
-
-    s.stop("Database created successfully!");
-
-    let createDbResponse: CreateDbResponse;
-    try {
-      createDbResponse = JSON.parse(stdout) as CreateDbResponse;
-    } catch {
-      consola.error("Failed to parse create-db response");
-      return null;
-    }
-
-    return {
-      databaseUrl: createDbResponse.connectionString,
-      claimUrl: createDbResponse.claimUrl,
-    };
-  } catch (error) {
-    if (error instanceof Error) {
-      consola.error(error.message);
-    }
-    return null;
-  }
-}
-
-async function writeEnvFile(
-  projectDir: string,
-  backend: ProjectConfig["backend"],
-  config?: PrismaConfig,
-) {
-  try {
-    const targetApp = backend === "self" ? "apps/web" : "apps/server";
-    const envPath = path.join(projectDir, targetApp, ".env");
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value:
-          config?.databaseUrl ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
-        condition: true,
-      },
-    ];
-
-    if (config?.claimUrl) {
-      variables.push({
-        key: "CLAIM_URL",
-        value: config.claimUrl,
-        condition: true,
-      });
-    }
-
-    await addEnvVariablesToFile(envPath, variables);
-  } catch {
-    consola.error("Failed to update environment configuration");
-  }
-}
-
-function displayManualSetupInstructions(target: "apps/web" | "apps/server") {
-  log.info(`Manual Prisma PostgreSQL Setup Instructions:
-
-1. Visit https://console.prisma.io and create an account
-2. Create a new PostgreSQL database from the dashboard
-3. Get your database URL
-4. Add the database URL to the .env file in ${target}/.env
-
-DATABASE_URL="your_database_url"`);
-}
-
-export async function setupPrismaPostgres(
-  config: ProjectConfig,
-  cliInput?: { manualDb?: boolean },
-) {
-  const { packageManager, projectDir, backend } = config;
-  const manualDb = cliInput?.manualDb ?? false;
-  const dbDir = path.join(projectDir, "packages/db");
-
-  try {
-    await fs.ensureDir(dbDir);
-
-    if (manualDb) {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-      return;
-    }
-
-    const setupMode = await select({
-      message: "Prisma Postgres setup: choose mode",
-      options: [
-        {
-          label: "Automatic (create-db)",
-          value: "auto",
-          hint: "Provision a database via Prisma's create-db CLI",
-        },
-        {
-          label: "Manual",
-          value: "manual",
-          hint: "Add your own DATABASE_URL later",
-        },
-      ],
-      initialValue: "auto",
-    });
-
-    if (isCancel(setupMode)) return;
-
-    if (setupMode === "manual") {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-      return;
-    }
-
-    const prismaConfig = await setupWithCreateDb(dbDir, packageManager);
-
-    if (prismaConfig) {
-      await writeEnvFile(projectDir, backend, prismaConfig);
-
-      log.success(pc.green("Prisma Postgres database configured successfully!"));
-
-      if (prismaConfig.claimUrl) {
-        log.info(pc.blue(`Claim URL saved to .env: ${prismaConfig.claimUrl}`));
-      }
-    } else {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-    }
-  } catch (error) {
-    consola.error(
-      pc.red(
-        `Error during Prisma Postgres setup: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      ),
-    );
-
-    try {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions(backend === "self" ? "apps/web" : "apps/server");
-    } catch {}
-
-    log.info("Setup completed with manual configuration required.");
-  }
-}

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

@@ -1,218 +0,0 @@
-import path from "node:path";
-import { isCancel, log, select } from "@clack/prompts";
-import { consola } from "consola";
-import { type ExecaError, 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";
-
-async function writeSupabaseEnvFile(
-  projectDir: string,
-  backend: ProjectConfig["backend"],
-  databaseUrl: string,
-) {
-  try {
-    const targetApp = backend === "self" ? "apps/web" : "apps/server";
-    const envPath = path.join(projectDir, targetApp, ".env");
-    const dbUrlToUse = databaseUrl || "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
-    const variables: EnvVariable[] = [
-      {
-        key: "DATABASE_URL",
-        value: dbUrlToUse,
-        condition: true,
-      },
-      {
-        key: "DIRECT_URL",
-        value: dbUrlToUse,
-        condition: true,
-      },
-    ];
-    await addEnvVariablesToFile(envPath, variables);
-    return true;
-  } catch (error) {
-    consola.error(pc.red("Failed to update .env file for Supabase."));
-    if (error instanceof Error) {
-      consola.error(error.message);
-    }
-    return false;
-  }
-}
-
-function extractDbUrl(output: string) {
-  const dbUrlMatch = output.match(/DB URL:\s*(postgresql:\/\/[^\s]+)/);
-  const url = dbUrlMatch?.[1];
-  if (url) {
-    return url;
-  }
-  return null;
-}
-
-async function initializeSupabase(serverDir: string, packageManager: PackageManager) {
-  log.info("Initializing Supabase project...");
-  try {
-    const supabaseInitCommand = getPackageExecutionCommand(packageManager, "supabase init");
-    await execa(supabaseInitCommand, {
-      cwd: serverDir,
-      stdio: "inherit",
-      shell: true,
-    });
-    log.success("Supabase project initialized");
-    return true;
-  } catch (error) {
-    consola.error(pc.red("Failed to initialize Supabase project."));
-    if (error instanceof Error) {
-      consola.error(error.message);
-    } else {
-      consola.error(String(error));
-    }
-    if (error instanceof Error && error.message.includes("ENOENT")) {
-      log.error(
-        pc.red("Supabase CLI not found. Please install it globally or ensure it's in your PATH."),
-      );
-      log.info("You can install it using: npm install -g supabase");
-    }
-    return false;
-  }
-}
-
-async function startSupabase(serverDir: string, packageManager: PackageManager) {
-  log.info("Starting Supabase services (this may take a moment)...");
-  const supabaseStartCommand = getPackageExecutionCommand(packageManager, "supabase start");
-  try {
-    const subprocess = execa(supabaseStartCommand, {
-      cwd: serverDir,
-      shell: true,
-    });
-
-    let stdoutData = "";
-
-    if (subprocess.stdout) {
-      subprocess.stdout.on("data", (data) => {
-        const text = data.toString();
-        process.stdout.write(text);
-        stdoutData += text;
-      });
-    }
-
-    if (subprocess.stderr) {
-      subprocess.stderr.pipe(process.stderr);
-    }
-
-    await subprocess;
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    return stdoutData;
-  } catch (error) {
-    consola.error(pc.red("Failed to start Supabase services."));
-    const execaError = error as ExecaError;
-    if (execaError?.message) {
-      consola.error(`Error details: ${execaError.message}`);
-      if (execaError.message.includes("Docker is not running")) {
-        log.error(pc.red("Docker is not running. Please start Docker and try again."));
-      }
-    } else {
-      consola.error(String(error));
-    }
-    return null;
-  }
-}
-
-function displayManualSupabaseInstructions(output?: string | null) {
-  log.info(
-    `"Manual Supabase Setup Instructions:"
-1. Ensure Docker is installed and running.
-2. Install the Supabase CLI (e.g., \`npm install -g supabase\`).
-3. Run \`supabase init\` in your project's \`packages/db\` directory.
-4. Run \`supabase start\` in your project's \`packages/db\` directory.
-5. Copy the 'DB URL' from the output.${
-      output
-        ? `
-${pc.bold("Relevant output from `supabase start`:")}
-${pc.dim(output)}`
-        : ""
-    }
-6. Add the DB URL to the .env file in \`packages/db/.env\` as \`DATABASE_URL\`:
-			${pc.gray('DATABASE_URL="your_supabase_db_url"')}`,
-  );
-}
-
-export async function setupSupabase(config: ProjectConfig, cliInput?: { manualDb?: boolean }) {
-  const { projectDir, packageManager, backend } = config;
-  const manualDb = cliInput?.manualDb ?? false;
-
-  const serverDir = path.join(projectDir, "packages", "db");
-
-  try {
-    await fs.ensureDir(serverDir);
-
-    if (manualDb) {
-      displayManualSupabaseInstructions();
-      await writeSupabaseEnvFile(projectDir, backend, "");
-      return;
-    }
-
-    const mode = await select({
-      message: "Supabase 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") {
-      displayManualSupabaseInstructions();
-      await writeSupabaseEnvFile(projectDir, backend, "");
-      return;
-    }
-
-    const initialized = await initializeSupabase(serverDir, packageManager);
-    if (!initialized) {
-      displayManualSupabaseInstructions();
-      return;
-    }
-
-    const supabaseOutput = await startSupabase(serverDir, packageManager);
-    if (!supabaseOutput) {
-      displayManualSupabaseInstructions();
-      return;
-    }
-
-    const dbUrl = extractDbUrl(supabaseOutput);
-
-    if (dbUrl) {
-      const envUpdated = await writeSupabaseEnvFile(projectDir, backend, dbUrl);
-
-      if (envUpdated) {
-        log.success(pc.green("Supabase local development setup ready!"));
-      } else {
-        log.error(pc.red("Supabase setup completed, but failed to update .env automatically."));
-        displayManualSupabaseInstructions(supabaseOutput);
-      }
-    } else {
-      log.error(pc.yellow("Supabase started, but could not extract DB URL automatically."));
-      displayManualSupabaseInstructions(supabaseOutput);
-    }
-  } catch (error) {
-    if (error instanceof Error) {
-      consola.error(pc.red(`Error during Supabase setup: ${error.message}`));
-    } else {
-      consola.error(pc.red(`An unknown error occurred during Supabase setup: ${String(error)}`));
-    }
-    displayManualSupabaseInstructions();
-  }
-}