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

package/src/prompts/addons.ts

@@ -1,178 +0,0 @@
-import { groupMultiselect, isCancel } from "@clack/prompts";
-import { DEFAULT_CONFIG } from "../constants";
-import { type Addons, AddonsSchema, type Auth, type Frontend } from "../types";
-import { getCompatibleAddons, validateAddonCompatibility } from "../utils/compatibility-rules";
-import { exitCancelled } from "../utils/errors";
-
-type AddonOption = {
-  value: Addons;
-  label: string;
-  hint: string;
-};
-
-function getAddonDisplay(addon: Addons): { label: string; hint: string } {
-  let label: string;
-  let hint: string;
-
-  switch (addon) {
-    case "turborepo":
-      label = "Turborepo";
-      hint = "High-performance build system";
-      break;
-    case "pwa":
-      label = "PWA";
-      hint = "Make your app installable and work offline";
-      break;
-    case "tauri":
-      label = "Tauri";
-      hint = "Build native desktop apps from your web frontend";
-      break;
-    case "biome":
-      label = "Biome";
-      hint = "Format, lint, and more";
-      break;
-    case "oxlint":
-      label = "Oxlint";
-      hint = "Rust-powered linter";
-      break;
-    case "ultracite":
-      label = "Ultracite";
-      hint = "Zero-config Biome preset with AI integration";
-      break;
-    case "ruler":
-      label = "Ruler";
-      hint = "Centralize your AI rules";
-      break;
-    case "husky":
-      label = "Husky";
-      hint = "Modern native Git hooks made easy";
-      break;
-    case "starlight":
-      label = "Starlight";
-      hint = "Build stellar docs with astro";
-      break;
-    case "fumadocs":
-      label = "Fumadocs";
-      hint = "Build excellent documentation site";
-      break;
-    default:
-      label = addon;
-      hint = `Add ${addon}`;
-  }
-
-  return { label, hint };
-}
-
-const ADDON_GROUPS = {
-  Documentation: ["starlight", "fumadocs"],
-  Linting: ["biome", "oxlint", "ultracite"],
-  Other: ["ruler", "turborepo", "pwa", "tauri", "husky"],
-};
-
-export async function getAddonsChoice(addons?: Addons[], frontends?: Frontend[], auth?: Auth) {
-  if (addons !== undefined) return addons;
-
-  const allAddons = AddonsSchema.options.filter((addon) => addon !== "none");
-  const groupedOptions: Record<string, AddonOption[]> = {
-    Documentation: [],
-    Linting: [],
-    Other: [],
-  };
-
-  const frontendsArray = frontends || [];
-
-  for (const addon of allAddons) {
-    const { isCompatible } = validateAddonCompatibility(addon, frontendsArray, auth);
-    if (!isCompatible) continue;
-
-    const { label, hint } = getAddonDisplay(addon);
-    const option = { value: addon, label, hint };
-
-    if (ADDON_GROUPS.Documentation.includes(addon)) {
-      groupedOptions.Documentation.push(option);
-    } else if (ADDON_GROUPS.Linting.includes(addon)) {
-      groupedOptions.Linting.push(option);
-    } else if (ADDON_GROUPS.Other.includes(addon)) {
-      groupedOptions.Other.push(option);
-    }
-  }
-
-  Object.keys(groupedOptions).forEach((group) => {
-    if (groupedOptions[group].length === 0) {
-      delete groupedOptions[group];
-    }
-  });
-
-  const initialValues = DEFAULT_CONFIG.addons.filter((addonValue) =>
-    Object.values(groupedOptions).some((options) =>
-      options.some((opt) => opt.value === addonValue),
-    ),
-  );
-
-  const response = await groupMultiselect<Addons>({
-    message: "Select addons",
-    options: groupedOptions,
-    initialValues: initialValues,
-    required: false,
-    selectableGroups: false,
-  });
-
-  if (isCancel(response)) return exitCancelled("Operation cancelled");
-
-  return response;
-}
-
-export async function getAddonsToAdd(
-  frontend: Frontend[],
-  existingAddons: Addons[] = [],
-  auth?: Auth,
-) {
-  const groupedOptions: Record<string, AddonOption[]> = {
-    Documentation: [],
-    Linting: [],
-    Other: [],
-  };
-
-  const frontendArray = frontend || [];
-
-  const compatibleAddons = getCompatibleAddons(
-    AddonsSchema.options.filter((addon) => addon !== "none"),
-    frontendArray,
-    existingAddons,
-    auth,
-  );
-
-  for (const addon of compatibleAddons) {
-    const { label, hint } = getAddonDisplay(addon);
-    const option = { value: addon, label, hint };
-
-    if (ADDON_GROUPS.Documentation.includes(addon)) {
-      groupedOptions.Documentation.push(option);
-    } else if (ADDON_GROUPS.Linting.includes(addon)) {
-      groupedOptions.Linting.push(option);
-    } else if (ADDON_GROUPS.Other.includes(addon)) {
-      groupedOptions.Other.push(option);
-    }
-  }
-
-  Object.keys(groupedOptions).forEach((group) => {
-    if (groupedOptions[group].length === 0) {
-      delete groupedOptions[group];
-    }
-  });
-
-  if (Object.keys(groupedOptions).length === 0) {
-    return [];
-  }
-
-  const response = await groupMultiselect<Addons>({
-    message: "Select addons to add",
-    options: groupedOptions,
-    required: false,
-    selectableGroups: false,
-  });
-
-  if (isCancel(response)) return exitCancelled("Operation cancelled");
-
-  return response;
-}

package/src/prompts/api.ts

@@ -1,49 +0,0 @@
-import { isCancel, select } from "@clack/prompts";
-import type { API, Backend, Frontend } from "../types";
-import { allowedApisForFrontends } from "../utils/compatibility-rules";
-import { exitCancelled } from "../utils/errors";
-
-export async function getApiChoice(
-  Api?: API | undefined,
-  frontend?: Frontend[],
-  backend?: Backend,
-) {
-  if (backend === "convex" || backend === "none") {
-    return "none";
-  }
-
-  const allowed = allowedApisForFrontends(frontend ?? []);
-
-  if (Api) {
-    return allowed.includes(Api) ? Api : allowed[0];
-  }
-  const apiOptions = allowed.map((a) =>
-    a === "trpc"
-      ? {
-          value: "trpc" as const,
-          label: "tRPC",
-          hint: "End-to-end typesafe APIs made easy",
-        }
-      : a === "orpc"
-        ? {
-            value: "orpc" as const,
-            label: "oRPC",
-            hint: "End-to-end type-safe APIs that adhere to OpenAPI standards",
-          }
-        : {
-            value: "none" as const,
-            label: "None",
-            hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)",
-          },
-  );
-
-  const apiType = await select<API>({
-    message: "Select API type",
-    options: apiOptions,
-    initialValue: apiOptions[0].value,
-  });
-
-  if (isCancel(apiType)) return exitCancelled("Operation cancelled");
-
-  return apiType;
-}

package/src/prompts/auth.ts

@@ -1,84 +0,0 @@
-import { isCancel, select } from "@clack/prompts";
-import { DEFAULT_CONFIG } from "../constants";
-import type { Auth, Backend } from "../types";
-import { exitCancelled } from "../utils/errors";
-
-export async function getAuthChoice(
-  auth: Auth | undefined,
-  backend?: Backend,
-  frontend?: string[],
-) {
-  if (auth !== undefined) return auth;
-  if (backend === "none") {
-    return "none" as Auth;
-  }
-  if (backend === "convex") {
-    const supportedBetterAuthFrontends = frontend?.some((f) =>
-      [
-        "tanstack-router",
-        "tanstack-start",
-        "next",
-        "native-bare",
-        "native-uniwind",
-        "native-unistyles",
-      ].includes(f),
-    );
-
-    const hasClerkCompatibleFrontends = frontend?.some((f) =>
-      [
-        "react-router",
-        "tanstack-router",
-        "tanstack-start",
-        "next",
-        "native-bare",
-        "native-uniwind",
-        "native-unistyles",
-      ].includes(f),
-    );
-
-    const options = [];
-
-    if (supportedBetterAuthFrontends) {
-      options.push({
-        value: "better-auth",
-        label: "Better-Auth",
-        hint: "comprehensive auth framework for TypeScript",
-      });
-    }
-
-    if (hasClerkCompatibleFrontends) {
-      options.push({
-        value: "clerk",
-        label: "Clerk",
-        hint: "More than auth, Complete User Management",
-      });
-    }
-
-    options.push({ value: "none", label: "None", hint: "No auth" });
-
-    const response = await select({
-      message: "Select authentication provider",
-      options,
-      initialValue: "none",
-    });
-    if (isCancel(response)) return exitCancelled("Operation cancelled");
-    return response as Auth;
-  }
-
-  const response = await select({
-    message: "Select authentication provider",
-    options: [
-      {
-        value: "better-auth",
-        label: "Better-Auth",
-        hint: "comprehensive auth framework for TypeScript",
-      },
-      { value: "none", label: "None" },
-    ],
-    initialValue: DEFAULT_CONFIG.auth,
-  });
-
-  if (isCancel(response)) return exitCancelled("Operation cancelled");
-
-  return response as Auth;
-}

package/src/prompts/backend.ts

@@ -1,83 +0,0 @@
-import { isCancel, select } from "@clack/prompts";
-import { DEFAULT_CONFIG } from "../constants";
-import type { Backend, Frontend } from "../types";
-import { exitCancelled } from "../utils/errors";
-
-// Temporarily restrict to Next.js and TanStack Start only for backend="self"
-const FULLSTACK_FRONTENDS: readonly Frontend[] = [
-  "next",
-  "tanstack-start",
-  // "nuxt",      // TODO: Add support in future update
-  // "svelte",    // TODO: Add support in future update
-] as const;
-
-export async function getBackendFrameworkChoice(
-  backendFramework?: Backend,
-  frontends?: Frontend[],
-) {
-  if (backendFramework !== undefined) return backendFramework;
-
-  const hasIncompatibleFrontend = frontends?.some((f) => f === "solid");
-  const hasFullstackFrontend = frontends?.some((f) => FULLSTACK_FRONTENDS.includes(f));
-
-  const backendOptions: Array<{
-    value: Backend;
-    label: string;
-    hint: string;
-  }> = [];
-
-  if (hasFullstackFrontend) {
-    backendOptions.push({
-      value: "self" as const,
-      label: "Self (Fullstack)",
-      hint: "Use frontend's built-in api routes",
-    });
-  }
-
-  backendOptions.push(
-    {
-      value: "hono" as const,
-      label: "Hono",
-      hint: "Lightweight, ultrafast web framework",
-    },
-    {
-      value: "express" as const,
-      label: "Express",
-      hint: "Fast, unopinionated, minimalist web framework for Node.js",
-    },
-    {
-      value: "fastify" as const,
-      label: "Fastify",
-      hint: "Fast, low-overhead web framework for Node.js",
-    },
-    {
-      value: "elysia" as const,
-      label: "Elysia",
-      hint: "Ergonomic web framework for building backend servers",
-    },
-  );
-
-  if (!hasIncompatibleFrontend) {
-    backendOptions.push({
-      value: "convex" as const,
-      label: "Convex",
-      hint: "Reactive backend-as-a-service platform",
-    });
-  }
-
-  backendOptions.push({
-    value: "none" as const,
-    label: "None",
-    hint: "No backend server",
-  });
-
-  const response = await select<Backend>({
-    message: "Select backend",
-    options: backendOptions,
-    initialValue: hasFullstackFrontend ? "self" : DEFAULT_CONFIG.backend,
-  });
-
-  if (isCancel(response)) return exitCancelled("Operation cancelled");
-
-  return response;
-}

package/src/prompts/config-prompts.ts

@@ -1,138 +0,0 @@
-import { group } from "@clack/prompts";
-import type {
-  Addons,
-  API,
-  Auth,
-  Backend,
-  Database,
-  DatabaseSetup,
-  Examples,
-  Frontend,
-  ORM,
-  PackageManager,
-  Payments,
-  ProjectConfig,
-  Runtime,
-  ServerDeploy,
-  WebDeploy,
-} from "../types";
-import { exitCancelled } from "../utils/errors";
-import { getAddonsChoice } from "./addons";
-import { getApiChoice } from "./api";
-import { getAuthChoice } from "./auth";
-import { getBackendFrameworkChoice } from "./backend";
-import { getDatabaseChoice } from "./database";
-import { getDBSetupChoice } from "./database-setup";
-import { getExamplesChoice } from "./examples";
-import { getFrontendChoice } from "./frontend";
-import { getGitChoice } from "./git";
-import { getinstallChoice } from "./install";
-import { getORMChoice } from "./orm";
-import { getPackageManagerChoice } from "./package-manager";
-import { getPaymentsChoice } from "./payments";
-import { getRuntimeChoice } from "./runtime";
-import { getServerDeploymentChoice } from "./server-deploy";
-import { getDeploymentChoice } from "./web-deploy";
-
-type PromptGroupResults = {
-  frontend: Frontend[];
-  backend: Backend;
-  runtime: Runtime;
-  database: Database;
-  orm: ORM;
-  api: API;
-  auth: Auth;
-  payments: Payments;
-  addons: Addons[];
-  examples: Examples[];
-  dbSetup: DatabaseSetup;
-  git: boolean;
-  packageManager: PackageManager;
-  install: boolean;
-  webDeploy: WebDeploy;
-  serverDeploy: ServerDeploy;
-};
-
-export async function gatherConfig(
-  flags: Partial<ProjectConfig>,
-  projectName: string,
-  projectDir: string,
-  relativePath: string,
-) {
-  const result = await group<PromptGroupResults>(
-    {
-      frontend: () => getFrontendChoice(flags.frontend, flags.backend, flags.auth),
-      backend: ({ results }) => getBackendFrameworkChoice(flags.backend, results.frontend),
-      runtime: ({ results }) => getRuntimeChoice(flags.runtime, results.backend),
-      database: ({ results }) =>
-        getDatabaseChoice(flags.database, results.backend, results.runtime),
-      orm: ({ results }) =>
-        getORMChoice(
-          flags.orm,
-          results.database !== "none",
-          results.database,
-          results.backend,
-          results.runtime,
-        ),
-      api: ({ results }) =>
-        getApiChoice(flags.api, results.frontend, results.backend) as Promise<API>,
-      auth: ({ results }) => getAuthChoice(flags.auth, results.backend, results.frontend),
-      payments: ({ results }) =>
-        getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend),
-      addons: ({ results }) => getAddonsChoice(flags.addons, results.frontend, results.auth),
-      examples: ({ results }) =>
-        getExamplesChoice(
-          flags.examples,
-          results.database,
-          results.frontend,
-          results.backend,
-          results.api,
-        ) as Promise<Examples[]>,
-      dbSetup: ({ results }) =>
-        getDBSetupChoice(
-          results.database ?? "none",
-          flags.dbSetup,
-          results.orm,
-          results.backend,
-          results.runtime,
-        ),
-      webDeploy: ({ results }) =>
-        getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend),
-      serverDeploy: ({ results }) =>
-        getServerDeploymentChoice(
-          flags.serverDeploy,
-          results.runtime,
-          results.backend,
-          results.webDeploy,
-        ),
-      git: () => getGitChoice(flags.git),
-      packageManager: () => getPackageManagerChoice(flags.packageManager),
-      install: () => getinstallChoice(flags.install),
-    },
-    {
-      onCancel: () => exitCancelled("Operation cancelled"),
-    },
-  );
-
-  return {
-    projectName: projectName,
-    projectDir: projectDir,
-    relativePath: relativePath,
-    frontend: result.frontend,
-    backend: result.backend,
-    runtime: result.runtime,
-    database: result.database,
-    orm: result.orm,
-    auth: result.auth,
-    payments: result.payments,
-    addons: result.addons,
-    examples: result.examples,
-    git: result.git,
-    packageManager: result.packageManager,
-    install: result.install,
-    dbSetup: result.dbSetup,
-    api: result.api,
-    webDeploy: result.webDeploy,
-    serverDeploy: result.serverDeploy,
-  };
-}

package/src/prompts/database-setup.ts

@@ -1,112 +0,0 @@
-import { isCancel, select } from "@clack/prompts";
-import type { Backend, DatabaseSetup, ORM, Runtime } from "../types";
-import { exitCancelled } from "../utils/errors";
-
-export async function getDBSetupChoice(
-  databaseType: string,
-  dbSetup: DatabaseSetup | undefined,
-  _orm?: ORM,
-  backend?: Backend,
-  runtime?: Runtime,
-) {
-  if (backend === "convex") {
-    return "none";
-  }
-
-  if (dbSetup !== undefined) return dbSetup as DatabaseSetup;
-
-  if (databaseType === "none") {
-    return "none";
-  }
-
-  let options: Array<{ value: DatabaseSetup; label: string; hint: string }> = [];
-
-  if (databaseType === "sqlite") {
-    options = [
-      {
-        value: "turso" as const,
-        label: "Turso",
-        hint: "SQLite for Production. Powered by libSQL",
-      },
-      ...(runtime === "workers"
-        ? [
-            {
-              value: "d1" as const,
-              label: "Cloudflare D1",
-              hint: "Cloudflare's managed, serverless database with SQLite's SQL semantics",
-            },
-          ]
-        : []),
-      { value: "none" as const, label: "None", hint: "Manual setup" },
-    ];
-  } else if (databaseType === "postgres") {
-    options = [
-      {
-        value: "neon" as const,
-        label: "Neon Postgres",
-        hint: "Serverless Postgres with branching capability",
-      },
-      {
-        value: "planetscale" as const,
-        label: "PlanetScale",
-        hint: "Postgres & Vitess (MySQL) on NVMe",
-      },
-      {
-        value: "supabase" as const,
-        label: "Supabase",
-        hint: "Local Supabase stack (requires Docker)",
-      },
-      {
-        value: "prisma-postgres" as const,
-        label: "Prisma Postgres",
-        hint: "Instant Postgres for Global Applications",
-      },
-      {
-        value: "docker" as const,
-        label: "Docker",
-        hint: "Run locally with docker compose",
-      },
-      { value: "none" as const, label: "None", hint: "Manual setup" },
-    ];
-  } else if (databaseType === "mysql") {
-    options = [
-      {
-        value: "planetscale" as const,
-        label: "PlanetScale",
-        hint: "MySQL on Vitess (NVMe, HA)",
-      },
-      {
-        value: "docker" as const,
-        label: "Docker",
-        hint: "Run locally with docker compose",
-      },
-      { value: "none" as const, label: "None", hint: "Manual setup" },
-    ];
-  } else if (databaseType === "mongodb") {
-    options = [
-      {
-        value: "mongodb-atlas" as const,
-        label: "MongoDB Atlas",
-        hint: "The most effective way to deploy MongoDB",
-      },
-      {
-        value: "docker" as const,
-        label: "Docker",
-        hint: "Run locally with docker compose",
-      },
-      { value: "none" as const, label: "None", hint: "Manual setup" },
-    ];
-  } else {
-    return "none";
-  }
-
-  const response = await select<DatabaseSetup>({
-    message: `Select ${databaseType} setup option`,
-    options,
-    initialValue: "none",
-  });
-
-  if (isCancel(response)) return exitCancelled("Operation cancelled");
-
-  return response;
-}

package/src/prompts/database.ts

@@ -1,57 +0,0 @@
-import { isCancel, select } from "@clack/prompts";
-import { DEFAULT_CONFIG } from "../constants";
-import type { Backend, Database, Runtime } from "../types";
-import { exitCancelled } from "../utils/errors";
-
-export async function getDatabaseChoice(database?: Database, backend?: Backend, runtime?: Runtime) {
-  if (backend === "convex" || backend === "none") {
-    return "none";
-  }
-
-  if (database !== undefined) return database;
-
-  const databaseOptions: Array<{
-    value: Database;
-    label: string;
-    hint: string;
-  }> = [
-    {
-      value: "none",
-      label: "None",
-      hint: "No database setup",
-    },
-    {
-      value: "sqlite",
-      label: "SQLite",
-      hint: "lightweight, server-less, embedded relational database",
-    },
-    {
-      value: "postgres",
-      label: "PostgreSQL",
-      hint: "powerful, open source object-relational database system",
-    },
-    {
-      value: "mysql",
-      label: "MySQL",
-      hint: "popular open-source relational database system",
-    },
-  ];
-
-  if (runtime !== "workers") {
-    databaseOptions.push({
-      value: "mongodb",
-      label: "MongoDB",
-      hint: "open-source NoSQL database that stores data in JSON-like documents called BSON",
-    });
-  }
-
-  const response = await select<Database>({
-    message: "Select database",
-    options: databaseOptions,
-    initialValue: DEFAULT_CONFIG.database,
-  });
-
-  if (isCancel(response)) return exitCancelled("Operation cancelled");
-
-  return response;
-}