create-better-t-stack 3.10.0 → 3.11.0-pr749.0

package/src/prompts/api.ts

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,57 @@
+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;
+}

package/src/prompts/examples.ts

@@ -0,0 +1,60 @@
+import { isCancel, multiselect } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { API, Backend, Database, Examples, Frontend } from "../types";
+import { isExampleAIAllowed, isExampleTodoAllowed } from "../utils/compatibility-rules";
+import { exitCancelled } from "../utils/errors";
+
+export async function getExamplesChoice(
+  examples?: Examples[],
+  database?: Database,
+  frontends?: Frontend[],
+  backend?: Backend,
+  api?: API,
+) {
+  if (examples !== undefined) return examples;
+
+  if (backend === "none") {
+    return [];
+  }
+
+  if (backend !== "convex") {
+    if (api === "none") {
+      return [];
+    }
+    if (database === "none") {
+      return [];
+    }
+  }
+
+  let response: Examples[] | symbol = [];
+  const options: { value: Examples; label: string; hint: string }[] = [];
+
+  if (isExampleTodoAllowed(backend, database)) {
+    options.push({
+      value: "todo" as const,
+      label: "Todo App",
+      hint: "A simple CRUD example app",
+    });
+  }
+
+  if (isExampleAIAllowed(backend, frontends ?? [])) {
+    options.push({
+      value: "ai" as const,
+      label: "AI Chat",
+      hint: "A simple AI chat interface using AI SDK",
+    });
+  }
+
+  if (options.length === 0) return [];
+
+  response = await multiselect<Examples>({
+    message: "Include examples",
+    options: options,
+    required: false,
+    initialValues: DEFAULT_CONFIG.examples?.filter((ex) => options.some((o) => o.value === ex)),
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/frontend.ts

@@ -0,0 +1,118 @@
+import { isCancel, multiselect, select } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { Backend, Frontend } from "../types";
+import { isFrontendAllowedWithBackend } from "../utils/compatibility-rules";
+import { exitCancelled } from "../utils/errors";
+
+export async function getFrontendChoice(
+  frontendOptions?: Frontend[],
+  backend?: Backend,
+  auth?: string,
+) {
+  if (frontendOptions !== undefined) return frontendOptions;
+
+  const frontendTypes = await multiselect({
+    message: "Select project type",
+    options: [
+      {
+        value: "web",
+        label: "Web",
+        hint: "React, Vue or Svelte Web Application",
+      },
+      {
+        value: "native",
+        label: "Native",
+        hint: "Create a React Native/Expo app",
+      },
+    ],
+    required: false,
+    initialValues: ["web"],
+  });
+
+  if (isCancel(frontendTypes)) return exitCancelled("Operation cancelled");
+
+  const result: Frontend[] = [];
+
+  if (frontendTypes.includes("web")) {
+    const allWebOptions = [
+      {
+        value: "tanstack-router" as const,
+        label: "TanStack Router",
+        hint: "Modern and scalable routing for React Applications",
+      },
+      {
+        value: "react-router" as const,
+        label: "React Router",
+        hint: "A user‑obsessed, standards‑focused, multi‑strategy router",
+      },
+      {
+        value: "next" as const,
+        label: "Next.js",
+        hint: "The React Framework for the Web",
+      },
+      {
+        value: "nuxt" as const,
+        label: "Nuxt",
+        hint: "The Progressive Web Framework for Vue.js",
+      },
+      {
+        value: "svelte" as const,
+        label: "Svelte",
+        hint: "web development for the rest of us",
+      },
+      {
+        value: "solid" as const,
+        label: "Solid",
+        hint: "Simple and performant reactivity for building user interfaces",
+      },
+      {
+        value: "tanstack-start" as const,
+        label: "TanStack Start",
+        hint: "SSR, Server Functions, API Routes and more with TanStack Router",
+      },
+    ];
+
+    const webOptions = allWebOptions.filter((option) =>
+      isFrontendAllowedWithBackend(option.value, backend, auth),
+    );
+
+    const webFramework = await select<Frontend>({
+      message: "Choose web",
+      options: webOptions,
+      initialValue: DEFAULT_CONFIG.frontend[0],
+    });
+
+    if (isCancel(webFramework)) return exitCancelled("Operation cancelled");
+
+    result.push(webFramework);
+  }
+
+  if (frontendTypes.includes("native")) {
+    const nativeFramework = await select<Frontend>({
+      message: "Choose native",
+      options: [
+        {
+          value: "native-bare" as const,
+          label: "Bare",
+          hint: "Bare Expo without styling library",
+        },
+        {
+          value: "native-uniwind" as const,
+          label: "Uniwind",
+          hint: "Fastest Tailwind bindings for React Native with HeroUI Native",
+        },
+        {
+          value: "native-unistyles" as const,
+          label: "Unistyles",
+          hint: "Consistent styling for React Native",
+        },
+      ],
+      initialValue: "native-bare",
+    });
+
+    if (isCancel(nativeFramework)) return exitCancelled("Operation cancelled");
+    result.push(nativeFramework);
+  }
+
+  return result;
+}