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

package/src/prompts/examples.ts

@@ -0,0 +1,64 @@
+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 (api === "none") {
+    if (backend === "convex") {
+      return ["todo"];
+    }
+    return [];
+  }
+
+  if (backend === "convex") {
+    return ["todo"];
+  }
+
+  if (backend === "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;
+}

package/src/prompts/git.ts

@@ -0,0 +1,16 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import { exitCancelled } from "../utils/errors";
+
+export async function getGitChoice(git?: boolean) {
+  if (git !== undefined) return git;
+
+  const response = await confirm({
+    message: "Initialize git repository?",
+    initialValue: DEFAULT_CONFIG.git,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/install.ts

@@ -0,0 +1,16 @@
+import { confirm, isCancel } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import { exitCancelled } from "../utils/errors";
+
+export async function getinstallChoice(install?: boolean) {
+  if (install !== undefined) return install;
+
+  const response = await confirm({
+    message: "Install dependencies?",
+    initialValue: DEFAULT_CONFIG.install,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/orm.ts

@@ -0,0 +1,53 @@
+import { isCancel, select } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { Backend, Database, ORM, Runtime } from "../types";
+import { exitCancelled } from "../utils/errors";
+
+const ormOptions = {
+  prisma: {
+    value: "prisma" as const,
+    label: "Prisma",
+    hint: "Powerful, feature-rich ORM",
+  },
+  mongoose: {
+    value: "mongoose" as const,
+    label: "Mongoose",
+    hint: "Elegant object modeling tool",
+  },
+  drizzle: {
+    value: "drizzle" as const,
+    label: "Drizzle",
+    hint: "Lightweight and performant TypeScript ORM",
+  },
+};
+
+export async function getORMChoice(
+  orm: ORM | undefined,
+  hasDatabase: boolean,
+  database?: Database,
+  backend?: Backend,
+  runtime?: Runtime,
+) {
+  if (backend === "convex") {
+    return "none";
+  }
+
+  if (!hasDatabase) return "none";
+  if (orm !== undefined) return orm;
+
+  const options =
+    database === "mongodb"
+      ? [ormOptions.prisma, ormOptions.mongoose]
+      : [ormOptions.drizzle, ormOptions.prisma];
+
+  const response = await select<ORM>({
+    message: "Select ORM",
+    options,
+    initialValue:
+      database === "mongodb" ? "prisma" : runtime === "workers" ? "drizzle" : DEFAULT_CONFIG.orm,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/package-manager.ts

@@ -0,0 +1,32 @@
+import { isCancel, select } from "@clack/prompts";
+import type { PackageManager } from "../types";
+import { exitCancelled } from "../utils/errors";
+import { getUserPkgManager } from "../utils/get-package-manager";
+
+export async function getPackageManagerChoice(packageManager?: PackageManager) {
+  if (packageManager !== undefined) return packageManager;
+
+  const detectedPackageManager = getUserPkgManager();
+
+  const response = await select<PackageManager>({
+    message: "Choose package manager",
+    options: [
+      { value: "npm", label: "npm", hint: "Node Package Manager" },
+      {
+        value: "pnpm",
+        label: "pnpm",
+        hint: "Fast, disk space efficient package manager",
+      },
+      {
+        value: "bun",
+        label: "bun",
+        hint: "All-in-one JavaScript runtime & toolkit",
+      },
+    ],
+    initialValue: detectedPackageManager,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/payments.ts

@@ -0,0 +1,50 @@
+import { isCancel, select } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { Auth, Backend, Frontend, Payments } from "../types";
+import { splitFrontends } from "../utils/compatibility-rules";
+import { exitCancelled } from "../utils/errors";
+
+export async function getPaymentsChoice(
+  payments?: Payments,
+  auth?: Auth,
+  backend?: Backend,
+  frontends?: Frontend[],
+) {
+  if (payments !== undefined) return payments;
+
+  if (backend === "none") {
+    return "none" as Payments;
+  }
+
+  const isPolarCompatible =
+    auth === "better-auth" &&
+    backend !== "convex" &&
+    (frontends?.length === 0 || splitFrontends(frontends).web.length > 0);
+
+  if (!isPolarCompatible) {
+    return "none" as Payments;
+  }
+
+  const options = [
+    {
+      value: "polar" as Payments,
+      label: "Polar",
+      hint: "Turn your software into a business. 6 lines of code.",
+    },
+    {
+      value: "none" as Payments,
+      label: "None",
+      hint: "No payments integration",
+    },
+  ];
+
+  const response = await select<Payments>({
+    message: "Select payments provider",
+    options,
+    initialValue: DEFAULT_CONFIG.payments,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/project-name.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { isCancel, text } from "@clack/prompts";
+import consola from "consola";
+import fs from "fs-extra";
+import pc from "picocolors";
+import { DEFAULT_CONFIG } from "../constants";
+import { ProjectNameSchema } from "../types";
+import { exitCancelled } from "../utils/errors";
+
+function isPathWithinCwd(targetPath: string) {
+  const resolved = path.resolve(targetPath);
+  const rel = path.relative(process.cwd(), resolved);
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+function validateDirectoryName(name: string) {
+  if (name === ".") return undefined;
+
+  const result = ProjectNameSchema.safeParse(name);
+  if (!result.success) {
+    return result.error.issues[0]?.message || "Invalid project name";
+  }
+  return undefined;
+}
+
+export async function getProjectName(initialName?: string) {
+  if (initialName) {
+    if (initialName === ".") {
+      return initialName;
+    }
+    const finalDirName = path.basename(initialName);
+    const validationError = validateDirectoryName(finalDirName);
+    if (!validationError) {
+      const projectDir = path.resolve(process.cwd(), initialName);
+      if (isPathWithinCwd(projectDir)) {
+        return initialName;
+      }
+      consola.error(pc.red("Project path must be within current directory"));
+    }
+  }
+
+  let isValid = false;
+  let projectPath = "";
+  let defaultName: string = DEFAULT_CONFIG.projectName;
+  let counter = 1;
+
+  while (
+    (await fs.pathExists(path.resolve(process.cwd(), defaultName))) &&
+    (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0
+  ) {
+    defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
+    counter++;
+  }
+
+  while (!isValid) {
+    const response = await text({
+      message: "Enter your project name or path (relative to current directory)",
+      placeholder: defaultName,
+      initialValue: initialName,
+      defaultValue: defaultName,
+      validate: (value) => {
+        const nameToUse = String(value ?? "").trim() || defaultName;
+
+        const finalDirName = path.basename(nameToUse);
+        const validationError = validateDirectoryName(finalDirName);
+        if (validationError) return validationError;
+
+        if (nameToUse !== ".") {
+          const projectDir = path.resolve(process.cwd(), nameToUse);
+          if (!isPathWithinCwd(projectDir)) {
+            return "Project path must be within current directory";
+          }
+        }
+
+        return undefined;
+      },
+    });
+
+    if (isCancel(response)) return exitCancelled("Operation cancelled.");
+
+    projectPath = response || defaultName;
+    isValid = true;
+  }
+
+  return projectPath;
+}

package/src/prompts/runtime.ts

@@ -0,0 +1,47 @@
+import { isCancel, select } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { Backend, Runtime } from "../types";
+import { exitCancelled } from "../utils/errors";
+
+export async function getRuntimeChoice(runtime?: Runtime, backend?: Backend) {
+  if (backend === "convex" || backend === "none" || backend === "self") {
+    return "none";
+  }
+
+  if (runtime !== undefined) return runtime;
+
+  const runtimeOptions: Array<{
+    value: Runtime;
+    label: string;
+    hint: string;
+  }> = [
+    {
+      value: "bun",
+      label: "Bun",
+      hint: "Fast all-in-one JavaScript runtime",
+    },
+    {
+      value: "node",
+      label: "Node.js",
+      hint: "Traditional Node.js runtime",
+    },
+  ];
+
+  if (backend === "hono") {
+    runtimeOptions.push({
+      value: "workers",
+      label: "Cloudflare Workers",
+      hint: "Edge runtime on Cloudflare's global network",
+    });
+  }
+
+  const response = await select<Runtime>({
+    message: "Select runtime",
+    options: runtimeOptions,
+    initialValue: DEFAULT_CONFIG.runtime,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/server-deploy.ts

@@ -0,0 +1,91 @@
+import { isCancel, select } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { Backend, Runtime, ServerDeploy, WebDeploy } from "../types";
+import { exitCancelled } from "../utils/errors";
+
+type DeploymentOption = {
+  value: ServerDeploy;
+  label: string;
+  hint: string;
+};
+
+function getDeploymentDisplay(deployment: ServerDeploy): {
+  label: string;
+  hint: string;
+} {
+  if (deployment === "alchemy") {
+    return {
+      label: "Alchemy",
+      hint: "Deploy to Cloudflare Workers using Alchemy",
+    };
+  }
+  return {
+    label: deployment,
+    hint: `Add ${deployment} deployment`,
+  };
+}
+
+export async function getServerDeploymentChoice(
+  deployment?: ServerDeploy,
+  runtime?: Runtime,
+  backend?: Backend,
+  _webDeploy?: WebDeploy,
+) {
+  if (deployment !== undefined) return deployment;
+
+  if (backend === "none" || backend === "convex") {
+    return "none";
+  }
+
+  if (backend !== "hono") {
+    return "none";
+  }
+
+  // Auto-select alchemy for workers runtime since it's the only valid option
+  if (runtime === "workers") {
+    return "alchemy";
+  }
+
+  return "none";
+}
+
+export async function getServerDeploymentToAdd(
+  runtime?: Runtime,
+  existingDeployment?: ServerDeploy,
+  backend?: Backend,
+) {
+  if (backend !== "hono") {
+    return "none";
+  }
+
+  const options: DeploymentOption[] = [];
+
+  if (runtime === "workers") {
+    if (existingDeployment !== "alchemy") {
+      const { label, hint } = getDeploymentDisplay("alchemy");
+      options.push({
+        value: "alchemy",
+        label,
+        hint,
+      });
+    }
+  }
+
+  if (existingDeployment && existingDeployment !== "none") {
+    return "none";
+  }
+
+  if (options.length === 0) {
+    return "none";
+  }
+
+  const response = await select<ServerDeploy>({
+    message: "Select server deployment",
+    options,
+    initialValue: DEFAULT_CONFIG.serverDeploy,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/prompts/web-deploy.ts

@@ -0,0 +1,107 @@
+import { isCancel, select } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import type { Backend, Frontend, Runtime, WebDeploy } from "../types";
+import { WEB_FRAMEWORKS } from "../utils/compatibility";
+import { exitCancelled } from "../utils/errors";
+
+function hasWebFrontend(frontends: Frontend[]) {
+  return frontends.some((f) => WEB_FRAMEWORKS.includes(f));
+}
+
+type DeploymentOption = {
+  value: WebDeploy;
+  label: string;
+  hint: string;
+};
+
+function getDeploymentDisplay(deployment: WebDeploy): {
+  label: string;
+  hint: string;
+} {
+  if (deployment === "alchemy") {
+    return {
+      label: "Alchemy",
+      hint: "Deploy to Cloudflare Workers using Alchemy",
+    };
+  }
+  return {
+    label: deployment,
+    hint: `Add ${deployment} deployment`,
+  };
+}
+
+export async function getDeploymentChoice(
+  deployment?: WebDeploy,
+  _runtime?: Runtime,
+  _backend?: Backend,
+  frontend: Frontend[] = [],
+) {
+  if (deployment !== undefined) return deployment;
+  if (!hasWebFrontend(frontend)) {
+    return "none";
+  }
+
+  const availableDeployments = ["alchemy", "none"];
+
+  const options: DeploymentOption[] = availableDeployments.map((deploy) => {
+    const { label, hint } = getDeploymentDisplay(deploy as WebDeploy);
+    return {
+      value: deploy as WebDeploy,
+      label,
+      hint,
+    };
+  });
+
+  const response = await select<WebDeploy>({
+    message: "Select web deployment",
+    options,
+    initialValue: DEFAULT_CONFIG.webDeploy,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}
+
+export async function getDeploymentToAdd(frontend: Frontend[], existingDeployment?: WebDeploy) {
+  if (!hasWebFrontend(frontend)) {
+    return "none";
+  }
+
+  const options: DeploymentOption[] = [];
+
+  if (existingDeployment !== "alchemy") {
+    const { label, hint } = getDeploymentDisplay("alchemy");
+    options.push({
+      value: "alchemy",
+      label,
+      hint,
+    });
+  }
+
+  if (existingDeployment && existingDeployment !== "none") {
+    return "none";
+  }
+
+  if (options.length > 0) {
+    options.push({
+      value: "none",
+      label: "None",
+      hint: "Skip deployment setup",
+    });
+  }
+
+  if (options.length === 0) {
+    return "none";
+  }
+
+  const response = await select<WebDeploy>({
+    message: "Select web deployment",
+    options,
+    initialValue: DEFAULT_CONFIG.webDeploy,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}

package/src/types.ts

@@ -0,0 +1,2 @@
+// Re-export everything from the shared types package
+export * from "@create-better-t-stack/types";