create-better-t-stack 3.7.3-canary.8e4d5716 → 3.7.3-canary.fe324be3

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

@@ -1,309 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { confirm, isCancel, log, select, spinner, text } from "@clack/prompts";
-import consola from "consola";
-import { $ } from "execa";
-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 TursoConfig = {
-  dbUrl: string;
-  authToken: string;
-};
-
-async function isTursoInstalled() {
-  return commandExists("turso");
-}
-
-async function isTursoLoggedIn() {
-  try {
-    const output = await $`turso auth whoami`;
-    return !output.stdout.includes("You are not logged in");
-  } catch {
-    return false;
-  }
-}
-
-async function loginToTurso() {
-  const s = spinner();
-  try {
-    s.start("Logging in to Turso...");
-    await $`turso auth login`;
-    s.stop("Logged into Turso");
-    return true;
-  } catch {
-    s.stop(pc.red("Failed to log in to Turso"));
-  }
-}
-
-async function installTursoCLI(isMac: boolean) {
-  const s = spinner();
-  try {
-    s.start("Installing Turso CLI...");
-
-    if (isMac) {
-      await $`brew install tursodatabase/tap/turso`;
-    } else {
-      const { stdout: installScript } = await $`curl -sSfL https://get.tur.so/install.sh`;
-      await $`bash -c '${installScript}'`;
-    }
-
-    s.stop("Turso CLI installed");
-    return true;
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("User force closed")) {
-      s.stop("Turso CLI installation cancelled");
-      log.warn(pc.yellow("Turso CLI installation cancelled by user"));
-      throw new Error("Installation cancelled");
-    }
-    s.stop(pc.red("Failed to install Turso CLI"));
-  }
-}
-
-async function getTursoGroups() {
-  const s = spinner();
-  try {
-    s.start("Fetching Turso groups...");
-    const { stdout } = await $`turso group list`;
-    const lines = stdout.trim().split("\n");
-
-    if (lines.length <= 1) {
-      s.stop("No Turso groups found");
-      return [];
-    }
-
-    const groups = lines.slice(1).map((line) => {
-      const [name, locations, version, status] = line.trim().split(/\s{2,}/);
-      return { name, locations, version, status };
-    });
-
-    s.stop(`Found ${groups.length} Turso groups`);
-    return groups;
-  } catch (error) {
-    s.stop(pc.red("Error fetching Turso groups"));
-    console.error("Error fetching Turso groups:", error);
-    return [];
-  }
-}
-
-async function selectTursoGroup() {
-  const groups = await getTursoGroups();
-
-  if (groups.length === 0) {
-    return null;
-  }
-
-  if (groups.length === 1) {
-    log.info(`Using the only available group: ${pc.blue(groups[0].name)}`);
-    return groups[0].name;
-  }
-
-  const groupOptions = groups.map((group) => ({
-    value: group.name,
-    label: `${group.name} (${group.locations})`,
-  }));
-
-  const selectedGroup = await select({
-    message: "Select a Turso database group:",
-    options: groupOptions,
-  });
-
-  if (isCancel(selectedGroup)) return exitCancelled("Operation cancelled");
-
-  return selectedGroup as string;
-}
-
-async function createTursoDatabase(dbName: string, groupName: string | null) {
-  const s = spinner();
-
-  try {
-    s.start(`Creating Turso database "${dbName}"${groupName ? ` in group "${groupName}"` : ""}...`);
-
-    if (groupName) {
-      await $`turso db create ${dbName} --group ${groupName}`;
-    } else {
-      await $`turso db create ${dbName}`;
-    }
-
-    s.stop(`Turso database "${dbName}" created`);
-  } catch (error) {
-    s.stop(pc.red(`Failed to create database "${dbName}"`));
-    if (error instanceof Error && error.message.includes("already exists")) {
-      throw new Error("DATABASE_EXISTS");
-    }
-  }
-
-  s.start("Retrieving database connection details...");
-  try {
-    const { stdout: dbUrl } = await $`turso db show ${dbName} --url`;
-    const { stdout: authToken } = await $`turso db tokens create ${dbName}`;
-
-    s.stop("Database connection details retrieved");
-
-    return {
-      dbUrl: dbUrl.trim(),
-      authToken: authToken.trim(),
-    };
-  } catch {
-    s.stop(pc.red("Failed to retrieve database connection details"));
-  }
-}
-
-async function writeEnvFile(
-  projectDir: string,
-  backend: ProjectConfig["backend"],
-  config?: TursoConfig,
-) {
-  const targetApp = backend === "self" ? "apps/web" : "apps/server";
-  const envPath = path.join(projectDir, targetApp, ".env");
-  const variables: EnvVariable[] = [
-    {
-      key: "DATABASE_URL",
-      value: config?.dbUrl ?? "",
-      condition: true,
-    },
-    {
-      key: "DATABASE_AUTH_TOKEN",
-      value: config?.authToken ?? "",
-      condition: true,
-    },
-  ];
-  await addEnvVariablesToFile(envPath, variables);
-}
-
-function displayManualSetupInstructions() {
-  log.info(`Manual Turso Setup Instructions:
-
-1. Visit https://turso.tech and create an account
-2. Create a new database from the dashboard
-3. Get your database URL and authentication token
-4. Add these credentials to the .env file in apps/server/.env
-
-DATABASE_URL=your_database_url
-DATABASE_AUTH_TOKEN=your_auth_token`);
-}
-
-export async function setupTurso(config: ProjectConfig, cliInput?: { manualDb?: boolean }) {
-  const { orm, projectDir, backend } = config;
-  const manualDb = cliInput?.manualDb ?? false;
-  const _isDrizzle = orm === "drizzle";
-  const setupSpinner = spinner();
-
-  try {
-    if (manualDb) {
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions();
-      return;
-    }
-
-    const mode = await select({
-      message: "Turso 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();
-      return;
-    }
-
-    setupSpinner.start("Checking Turso CLI availability...");
-    const platform = os.platform();
-    const isMac = platform === "darwin";
-    const _isLinux = platform === "linux";
-    const isWindows = platform === "win32";
-
-    if (isWindows) {
-      if (setupSpinner) setupSpinner.stop(pc.yellow("Turso setup not supported on Windows"));
-      log.warn(pc.yellow("Automatic Turso setup is not supported on Windows."));
-      await writeEnvFile(projectDir, backend);
-      displayManualSetupInstructions();
-      return;
-    }
-
-    if (setupSpinner) setupSpinner.stop("Turso CLI availability checked");
-
-    const isCliInstalled = await isTursoInstalled();
-
-    if (!isCliInstalled) {
-      const shouldInstall = await confirm({
-        message: "Would you like to install Turso CLI?",
-        initialValue: true,
-      });
-
-      if (isCancel(shouldInstall)) return exitCancelled("Operation cancelled");
-
-      if (!shouldInstall) {
-        await writeEnvFile(projectDir, backend);
-        displayManualSetupInstructions();
-        return;
-      }
-
-      await installTursoCLI(isMac);
-    }
-
-    const isLoggedIn = await isTursoLoggedIn();
-    if (!isLoggedIn) {
-      await loginToTurso();
-    }
-
-    const selectedGroup = await selectTursoGroup();
-
-    let success = false;
-    let dbName = "";
-    let suggestedName = path.basename(projectDir);
-
-    while (!success) {
-      const dbNameResponse = await text({
-        message: "Enter a name for your database:",
-        defaultValue: suggestedName,
-        initialValue: suggestedName,
-        placeholder: suggestedName,
-      });
-
-      if (isCancel(dbNameResponse)) return exitCancelled("Operation cancelled");
-
-      dbName = dbNameResponse as string;
-
-      try {
-        const config = await createTursoDatabase(dbName, selectedGroup);
-        await writeEnvFile(projectDir, backend, config);
-        success = true;
-      } catch (error) {
-        if (error instanceof Error && error.message === "DATABASE_EXISTS") {
-          log.warn(pc.yellow(`Database "${pc.red(dbName)}" already exists`));
-          suggestedName = `${dbName}-${Math.floor(Math.random() * 1000)}`;
-        } else {
-          throw error;
-        }
-      }
-    }
-
-    log.success("Turso database setup completed successfully!");
-  } catch (error) {
-    if (setupSpinner) setupSpinner.stop(pc.red("Turso CLI availability check failed"));
-    consola.error(
-      pc.red(`Error during Turso setup: ${error instanceof Error ? error.message : String(error)}`),
-    );
-    await writeEnvFile(projectDir, backend);
-    displayManualSetupInstructions();
-    log.success("Setup completed with manual configuration required.");
-  }
-}

package/src/helpers/deployment/alchemy/alchemy-combined-setup.ts

@@ -1,80 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import type { PackageManager, ProjectConfig } from "../../../types";
-import { addPackageDependency } from "../../../utils/add-package-deps";
-import { setupAlchemyServerDeploy } from "../server-deploy-setup";
-import { setupNextAlchemyDeploy } from "./alchemy-next-setup";
-import { setupNuxtAlchemyDeploy } from "./alchemy-nuxt-setup";
-import { setupReactRouterAlchemyDeploy } from "./alchemy-react-router-setup";
-import { setupSolidAlchemyDeploy } from "./alchemy-solid-setup";
-import { setupSvelteAlchemyDeploy } from "./alchemy-svelte-setup";
-import { setupTanStackRouterAlchemyDeploy } from "./alchemy-tanstack-router-setup";
-import { setupTanStackStartAlchemyDeploy } from "./alchemy-tanstack-start-setup";
-
-export async function setupCombinedAlchemyDeploy(
-  projectDir: string,
-  packageManager: PackageManager,
-  config: ProjectConfig,
-) {
-  await addPackageDependency({
-    devDependencies: ["alchemy"],
-    projectDir,
-  });
-
-  const rootPkgPath = path.join(projectDir, "package.json");
-  if (await fs.pathExists(rootPkgPath)) {
-    const pkg = await fs.readJson(rootPkgPath);
-
-    pkg.scripts = {
-      ...pkg.scripts,
-      deploy: "alchemy deploy",
-      destroy: "alchemy destroy",
-      dev: "alchemy dev",
-    };
-    await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
-  }
-
-  const serverDir = path.join(projectDir, "apps/server");
-  if (await fs.pathExists(serverDir)) {
-    await setupAlchemyServerDeploy(serverDir, projectDir);
-  }
-
-  const frontend = config.frontend;
-  const isNext = frontend.includes("next");
-  const isNuxt = frontend.includes("nuxt");
-  const isSvelte = frontend.includes("svelte");
-  const isTanstackRouter = frontend.includes("tanstack-router");
-  const isTanstackStart = frontend.includes("tanstack-start");
-  const isReactRouter = frontend.includes("react-router");
-  const isSolid = frontend.includes("solid");
-
-  if (isNext) {
-    await setupNextAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  } else if (isNuxt) {
-    await setupNuxtAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  } else if (isSvelte) {
-    await setupSvelteAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  } else if (isTanstackStart) {
-    await setupTanStackStartAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  } else if (isTanstackRouter) {
-    await setupTanStackRouterAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  } else if (isReactRouter) {
-    await setupReactRouterAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  } else if (isSolid) {
-    await setupSolidAlchemyDeploy(projectDir, packageManager, {
-      skipAppScripts: true,
-    });
-  }
-}

package/src/helpers/deployment/alchemy/alchemy-next-setup.ts

@@ -1,51 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import type { PackageManager } from "../../../types";
-import { addPackageDependency } from "../../../utils/add-package-deps";
-
-export async function setupNextAlchemyDeploy(
-  projectDir: string,
-  _packageManager: PackageManager,
-  options?: { skipAppScripts?: boolean },
-) {
-  const webAppDir = path.join(projectDir, "apps/web");
-  if (!(await fs.pathExists(webAppDir))) return;
-
-  await addPackageDependency({
-    dependencies: ["@opennextjs/cloudflare"],
-    devDependencies: ["alchemy", "wrangler", "@cloudflare/workers-types"],
-    projectDir: webAppDir,
-  });
-
-  const pkgPath = path.join(webAppDir, "package.json");
-  if (await fs.pathExists(pkgPath)) {
-    const pkg = await fs.readJson(pkgPath);
-
-    if (!options?.skipAppScripts) {
-      pkg.scripts = {
-        ...pkg.scripts,
-        deploy: "alchemy deploy",
-        destroy: "alchemy destroy",
-      };
-    }
-    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-  }
-
-  const openNextConfigPath = path.join(webAppDir, "open-next.config.ts");
-  const openNextConfigContent = `import { defineCloudflareConfig } from "@opennextjs/cloudflare";
-
-export default defineCloudflareConfig({});
-`;
-
-  await fs.writeFile(openNextConfigPath, openNextConfigContent);
-
-  const gitignorePath = path.join(webAppDir, ".gitignore");
-  if (await fs.pathExists(gitignorePath)) {
-    const gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
-    if (!gitignoreContent.includes("wrangler.jsonc")) {
-      await fs.appendFile(gitignorePath, "\nwrangler.jsonc\n");
-    }
-  } else {
-    await fs.writeFile(gitignorePath, "wrangler.jsonc\n");
-  }
-}

package/src/helpers/deployment/alchemy/alchemy-nuxt-setup.ts

@@ -1,104 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import { IndentationText, Node, Project, QuoteKind } from "ts-morph";
-import type { PackageManager } from "../../../types";
-import { addPackageDependency } from "../../../utils/add-package-deps";
-
-export async function setupNuxtAlchemyDeploy(
-  projectDir: string,
-  _packageManager: PackageManager,
-  options?: { skipAppScripts?: boolean },
-) {
-  const webAppDir = path.join(projectDir, "apps/web");
-  if (!(await fs.pathExists(webAppDir))) return;
-
-  await addPackageDependency({
-    devDependencies: ["alchemy", "nitro-cloudflare-dev", "wrangler"],
-    projectDir: webAppDir,
-  });
-
-  const pkgPath = path.join(webAppDir, "package.json");
-  if (await fs.pathExists(pkgPath)) {
-    const pkg = await fs.readJson(pkgPath);
-
-    if (!options?.skipAppScripts) {
-      pkg.scripts = {
-        ...pkg.scripts,
-        deploy: "alchemy deploy",
-        destroy: "alchemy destroy",
-      };
-    }
-    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-  }
-
-  const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
-  if (!(await fs.pathExists(nuxtConfigPath))) return;
-
-  try {
-    const project = new Project({
-      manipulationSettings: {
-        indentationText: IndentationText.TwoSpaces,
-        quoteKind: QuoteKind.Double,
-      },
-    });
-
-    project.addSourceFileAtPath(nuxtConfigPath);
-    const sourceFile = project.getSourceFileOrThrow(nuxtConfigPath);
-
-    const exportAssignment = sourceFile.getExportAssignment((d) => !d.isExportEquals());
-    if (!exportAssignment) return;
-
-    const defineConfigCall = exportAssignment.getExpression();
-    if (
-      !Node.isCallExpression(defineConfigCall) ||
-      defineConfigCall.getExpression().getText() !== "defineNuxtConfig"
-    )
-      return;
-
-    let configObject = defineConfigCall.getArguments()[0];
-    if (!configObject) {
-      configObject = defineConfigCall.addArgument("{}");
-    }
-
-    if (Node.isObjectLiteralExpression(configObject)) {
-      if (!configObject.getProperty("nitro")) {
-        configObject.addPropertyAssignment({
-          name: "nitro",
-          initializer: `{
-    preset: "cloudflare_module",
-    cloudflare: {
-      deployConfig: true,
-      nodeCompat: true
-    }
-  }`,
-        });
-      }
-
-      const modulesProperty = configObject.getProperty("modules");
-      if (modulesProperty && Node.isPropertyAssignment(modulesProperty)) {
-        const initializer = modulesProperty.getInitializer();
-        if (Node.isArrayLiteralExpression(initializer)) {
-          const hasModule = initializer
-            .getElements()
-            .some(
-              (el) =>
-                el.getText() === '"nitro-cloudflare-dev"' ||
-                el.getText() === "'nitro-cloudflare-dev'",
-            );
-          if (!hasModule) {
-            initializer.addElement('"nitro-cloudflare-dev"');
-          }
-        }
-      } else if (!modulesProperty) {
-        configObject.addPropertyAssignment({
-          name: "modules",
-          initializer: '["nitro-cloudflare-dev"]',
-        });
-      }
-    }
-
-    await project.save();
-  } catch (error) {
-    console.warn("Failed to update nuxt.config.ts:", error);
-  }
-}

package/src/helpers/deployment/alchemy/alchemy-react-router-setup.ts

@@ -1,32 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import type { PackageManager } from "../../../types";
-import { addPackageDependency } from "../../../utils/add-package-deps";
-
-export async function setupReactRouterAlchemyDeploy(
-  projectDir: string,
-  _packageManager: PackageManager,
-  options?: { skipAppScripts?: boolean },
-) {
-  const webAppDir = path.join(projectDir, "apps/web");
-  if (!(await fs.pathExists(webAppDir))) return;
-
-  await addPackageDependency({
-    devDependencies: ["alchemy"],
-    projectDir: webAppDir,
-  });
-
-  const pkgPath = path.join(webAppDir, "package.json");
-  if (await fs.pathExists(pkgPath)) {
-    const pkg = await fs.readJson(pkgPath);
-
-    if (!options?.skipAppScripts) {
-      pkg.scripts = {
-        ...pkg.scripts,
-        deploy: "alchemy deploy",
-        destroy: "alchemy destroy",
-      };
-    }
-    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-  }
-}

package/src/helpers/deployment/alchemy/alchemy-solid-setup.ts

@@ -1,32 +0,0 @@
-import path from "node:path";
-import fs from "fs-extra";
-import type { PackageManager } from "../../../types";
-import { addPackageDependency } from "../../../utils/add-package-deps";
-
-export async function setupSolidAlchemyDeploy(
-  projectDir: string,
-  _packageManager: PackageManager,
-  options?: { skipAppScripts?: boolean },
-) {
-  const webAppDir = path.join(projectDir, "apps/web");
-  if (!(await fs.pathExists(webAppDir))) return;
-
-  await addPackageDependency({
-    devDependencies: ["alchemy"],
-    projectDir: webAppDir,
-  });
-
-  const pkgPath = path.join(webAppDir, "package.json");
-  if (await fs.pathExists(pkgPath)) {
-    const pkg = await fs.readJson(pkgPath);
-
-    if (!options?.skipAppScripts) {
-      pkg.scripts = {
-        ...pkg.scripts,
-        deploy: "alchemy deploy",
-        destroy: "alchemy destroy",
-      };
-    }
-    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-  }
-}