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

package/src/helpers/core/auth-setup.ts

@@ -0,0 +1,203 @@
+import path from "node:path";
+import consola from "consola";
+import fs from "fs-extra";
+import pc from "picocolors";
+import type { ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+import { setupBetterAuthPlugins } from "../../utils/better-auth-plugin-setup";
+
+export async function setupAuth(config: ProjectConfig) {
+  const { auth, frontend, backend, projectDir } = config;
+  if (!auth || auth === "none") {
+    return;
+  }
+
+  const serverDir = path.join(projectDir, "apps/server");
+  const clientDir = path.join(projectDir, "apps/web");
+  const nativeDir = path.join(projectDir, "apps/native");
+
+  const clientDirExists = await fs.pathExists(clientDir);
+  const nativeDirExists = await fs.pathExists(nativeDir);
+  const _serverDirExists = await fs.pathExists(serverDir);
+
+  try {
+    if (backend === "convex") {
+      if (auth === "clerk" && clientDirExists) {
+        const hasNextJs = frontend.includes("next");
+        const hasTanStackStart = frontend.includes("tanstack-start");
+        const hasViteReactOther = frontend.some((f) =>
+          ["tanstack-router", "react-router"].includes(f),
+        );
+
+        if (hasNextJs) {
+          await addPackageDependency({
+            dependencies: ["@clerk/nextjs"],
+            projectDir: clientDir,
+          });
+        } else if (hasTanStackStart) {
+          await addPackageDependency({
+            dependencies: ["@clerk/tanstack-react-start", "srvx"],
+            projectDir: clientDir,
+          });
+        } else if (hasViteReactOther) {
+          await addPackageDependency({
+            dependencies: ["@clerk/clerk-react"],
+            projectDir: clientDir,
+          });
+        }
+      }
+
+      if (auth === "better-auth") {
+        const convexBackendDir = path.join(projectDir, "packages/backend");
+        const convexBackendDirExists = await fs.pathExists(convexBackendDir);
+
+        const hasNativeForBA =
+          frontend.includes("native-bare") ||
+          frontend.includes("native-uniwind") ||
+          frontend.includes("native-unistyles");
+
+        if (convexBackendDirExists) {
+          await addPackageDependency({
+            dependencies: ["better-auth", "@convex-dev/better-auth"],
+            customDependencies: { "better-auth": "1.4.7" },
+            projectDir: convexBackendDir,
+          });
+          if (hasNativeForBA) {
+            await addPackageDependency({
+              dependencies: ["@better-auth/expo"],
+              customDependencies: { "@better-auth/expo": "1.4.7" },
+              projectDir: convexBackendDir,
+            });
+          }
+        }
+
+        if (clientDirExists) {
+          const hasNextJs = frontend.includes("next");
+          const hasTanStackStart = frontend.includes("tanstack-start");
+          const hasViteReactOther = frontend.some((f) =>
+            ["tanstack-router", "react-router"].includes(f),
+          );
+
+          if (hasNextJs) {
+            await addPackageDependency({
+              dependencies: ["better-auth", "@convex-dev/better-auth"],
+              customDependencies: { "better-auth": "1.4.7" },
+              projectDir: clientDir,
+            });
+          } else if (hasTanStackStart) {
+            await addPackageDependency({
+              dependencies: ["better-auth", "@convex-dev/better-auth"],
+              customDependencies: { "better-auth": "1.4.7" },
+              projectDir: clientDir,
+            });
+          } else if (hasViteReactOther) {
+            await addPackageDependency({
+              dependencies: ["better-auth", "@convex-dev/better-auth"],
+              customDependencies: { "better-auth": "1.4.7" },
+              projectDir: clientDir,
+            });
+          }
+        }
+
+        const hasNativeBare = frontend.includes("native-bare");
+        const hasNativeUniwind = frontend.includes("native-uniwind");
+        const hasUnistyles = frontend.includes("native-unistyles");
+        if (nativeDirExists && (hasNativeBare || hasNativeUniwind || hasUnistyles)) {
+          await addPackageDependency({
+            dependencies: ["better-auth", "@better-auth/expo", "@convex-dev/better-auth"],
+            customDependencies: {
+              "better-auth": "1.4.7",
+              "@better-auth/expo": "1.4.7",
+            },
+            projectDir: nativeDir,
+          });
+        }
+      }
+
+      const hasNativeBare = frontend.includes("native-bare");
+      const hasNativeUniwind = frontend.includes("native-uniwind");
+      const hasUnistyles = frontend.includes("native-unistyles");
+      if (
+        auth === "clerk" &&
+        nativeDirExists &&
+        (hasNativeBare || hasNativeUniwind || hasUnistyles)
+      ) {
+        await addPackageDependency({
+          dependencies: ["@clerk/clerk-expo"],
+          projectDir: nativeDir,
+        });
+      }
+      return;
+    }
+
+    const authPackageDir = path.join(projectDir, "packages/auth");
+    const authPackageDirExists = await fs.pathExists(authPackageDir);
+
+    if (authPackageDirExists && auth === "better-auth") {
+      await addPackageDependency({
+        dependencies: ["better-auth"],
+        projectDir: authPackageDir,
+      });
+    }
+
+    const hasWebFrontend = frontend.some((f) =>
+      [
+        "react-router",
+        "tanstack-router",
+        "tanstack-start",
+        "next",
+        "nuxt",
+        "svelte",
+        "solid",
+      ].includes(f),
+    );
+
+    if (hasWebFrontend && clientDirExists) {
+      if (auth === "better-auth") {
+        await addPackageDependency({
+          dependencies: ["better-auth"],
+          projectDir: clientDir,
+        });
+      }
+    }
+
+    if (
+      (frontend.includes("native-bare") ||
+        frontend.includes("native-uniwind") ||
+        frontend.includes("native-unistyles")) &&
+      nativeDirExists
+    ) {
+      if (auth === "better-auth") {
+        await addPackageDependency({
+          dependencies: ["better-auth", "@better-auth/expo"],
+          projectDir: nativeDir,
+        });
+        if (authPackageDirExists) {
+          await addPackageDependency({
+            dependencies: ["@better-auth/expo"],
+            projectDir: authPackageDir,
+          });
+        }
+      }
+    }
+
+    if (authPackageDirExists && auth === "better-auth") {
+      await setupBetterAuthPlugins(projectDir, config);
+    }
+  } catch (error) {
+    consola.error(pc.red("Failed to configure authentication dependencies"));
+    if (error instanceof Error) {
+      consola.error(pc.red(error.message));
+    }
+  }
+}
+
+export function generateAuthSecret(length = 32) {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  const charactersLength = characters.length;
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}

package/src/helpers/core/backend-setup.ts

@@ -0,0 +1,69 @@
+import path from "node:path";
+import type { AvailableDependencies } from "../../constants";
+import type { ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+
+export async function setupBackendDependencies(config: ProjectConfig) {
+  const { backend, runtime, api, auth, projectDir } = config;
+
+  if (backend === "convex") {
+    const convexBackendDir = path.join(projectDir, "packages/backend");
+    await addPackageDependency({
+      dependencies: ["convex"],
+      projectDir: convexBackendDir,
+    });
+    return;
+  }
+
+  const framework = backend;
+  const serverDir = path.join(projectDir, "apps/server");
+
+  const dependencies: AvailableDependencies[] = [];
+  const devDependencies: AvailableDependencies[] = [];
+
+  if (framework === "hono") {
+    dependencies.push("hono");
+    if (runtime === "node") {
+      dependencies.push("@hono/node-server");
+    }
+  } else if (framework === "elysia") {
+    dependencies.push("elysia", "@elysiajs/cors");
+    if (runtime === "node") {
+      dependencies.push("@elysiajs/node");
+    }
+  } else if (framework === "express") {
+    dependencies.push("express", "cors");
+    devDependencies.push("@types/express", "@types/cors");
+  } else if (framework === "fastify") {
+    dependencies.push("fastify", "@fastify/cors");
+  }
+
+  if (api === "trpc") {
+    dependencies.push("@trpc/server");
+    if (framework === "hono") {
+      dependencies.push("@hono/trpc-server");
+    } else if (framework === "elysia") {
+      dependencies.push("@elysiajs/trpc");
+    }
+  } else if (api === "orpc") {
+    dependencies.push("@orpc/server", "@orpc/openapi", "@orpc/zod");
+  }
+
+  if (auth === "better-auth") {
+    dependencies.push("better-auth");
+  }
+
+  if (runtime === "node") {
+    devDependencies.push("tsx", "@types/node");
+  } else if (runtime === "bun") {
+    devDependencies.push("@types/bun");
+  }
+
+  if (dependencies.length > 0 || devDependencies.length > 0) {
+    await addPackageDependency({
+      dependencies,
+      devDependencies,
+      projectDir: serverDir,
+    });
+  }
+}

package/src/helpers/core/command-handlers.ts

@@ -0,0 +1,354 @@
+import path from "node:path";
+import { intro, log, outro } from "@clack/prompts";
+import consola from "consola";
+import fs from "fs-extra";
+import pc from "picocolors";
+import { getDefaultConfig } from "../../constants";
+import { getAddonsToAdd } from "../../prompts/addons";
+import { gatherConfig } from "../../prompts/config-prompts";
+import { getProjectName } from "../../prompts/project-name";
+import { getServerDeploymentToAdd } from "../../prompts/server-deploy";
+import { getDeploymentToAdd } from "../../prompts/web-deploy";
+import type { AddInput, CreateInput, DirectoryConflict, ProjectConfig } from "../../types";
+import { trackProjectCreation } from "../../utils/analytics";
+
+import { displayConfig } from "../../utils/display-config";
+import { exitWithError, handleError } from "../../utils/errors";
+import { generateReproducibleCommand } from "../../utils/generate-reproducible-command";
+import { handleDirectoryConflict, setupProjectDirectory } from "../../utils/project-directory";
+import { renderTitle } from "../../utils/render-title";
+import { getTemplateConfig, getTemplateDescription } from "../../utils/templates";
+import {
+  getProvidedFlags,
+  processAndValidateFlags,
+  processProvidedFlagsWithoutValidation,
+  validateConfigCompatibility,
+} from "../../validation";
+import { addAddonsToProject } from "./add-addons";
+import { addDeploymentToProject } from "./add-deployment";
+import { createProject } from "./create-project";
+import { detectProjectConfig } from "./detect-project-config";
+import { installDependencies } from "./install-dependencies";
+
+export async function createProjectHandler(input: CreateInput & { projectName?: string }) {
+  const startTime = Date.now();
+  const timeScaffolded = new Date().toISOString();
+
+  if (input.renderTitle !== false) {
+    renderTitle();
+  }
+  intro(pc.magenta("Creating a new Better-T-Stack project"));
+
+  if (input.yolo) {
+    consola.fatal("YOLO mode enabled - skipping checks. Things may break!");
+  }
+
+  let currentPathInput: string;
+  if (input.yes && input.projectName) {
+    currentPathInput = input.projectName;
+  } else if (input.yes) {
+    const defaultConfig = getDefaultConfig();
+    let defaultName: string = defaultConfig.relativePath;
+    let counter = 1;
+    while (
+      (await fs.pathExists(path.resolve(process.cwd(), defaultName))) &&
+      (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0
+    ) {
+      defaultName = `${defaultConfig.projectName}-${counter}`;
+      counter++;
+    }
+    currentPathInput = defaultName;
+  } else {
+    currentPathInput = await getProjectName(input.projectName);
+  }
+
+  let finalPathInput: string;
+  let shouldClearDirectory: boolean;
+
+  try {
+    if (input.directoryConflict) {
+      const result = await handleDirectoryConflictProgrammatically(
+        currentPathInput,
+        input.directoryConflict,
+      );
+      finalPathInput = result.finalPathInput;
+      shouldClearDirectory = result.shouldClearDirectory;
+    } else {
+      const result = await handleDirectoryConflict(currentPathInput);
+      finalPathInput = result.finalPathInput;
+      shouldClearDirectory = result.shouldClearDirectory;
+    }
+  } catch (error) {
+    const elapsedTimeMs = Date.now() - startTime;
+    return {
+      success: false,
+      projectConfig: {
+        projectName: "",
+        projectDir: "",
+        relativePath: "",
+        database: "none",
+        orm: "none",
+        backend: "none",
+        runtime: "none",
+        frontend: [],
+        addons: [],
+        examples: [],
+        auth: "none",
+        payments: "none",
+        git: false,
+        packageManager: "npm",
+        install: false,
+        dbSetup: "none",
+        api: "none",
+        webDeploy: "none",
+        serverDeploy: "none",
+      } satisfies ProjectConfig,
+      reproducibleCommand: "",
+      timeScaffolded,
+      elapsedTimeMs,
+      projectDirectory: "",
+      relativePath: "",
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  const { finalResolvedPath, finalBaseName } = await setupProjectDirectory(
+    finalPathInput,
+    shouldClearDirectory,
+  );
+
+  const originalInput = {
+    ...input,
+    projectDirectory: input.projectName,
+  };
+
+  const providedFlags = getProvidedFlags(originalInput);
+
+  let cliInput = originalInput;
+
+  if (input.template && input.template !== "none") {
+    const templateConfig = getTemplateConfig(input.template);
+    if (templateConfig) {
+      const templateName = input.template.toUpperCase();
+      const templateDescription = getTemplateDescription(input.template);
+      log.message(pc.bold(pc.cyan(`Using template: ${pc.white(templateName)}`)));
+      log.message(pc.dim(`   ${templateDescription}`));
+      const userOverrides: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(originalInput)) {
+        if (value !== undefined) {
+          userOverrides[key] = value;
+        }
+      }
+      cliInput = {
+        ...templateConfig,
+        ...userOverrides,
+        template: input.template,
+        projectDirectory: originalInput.projectDirectory,
+      };
+    }
+  }
+
+  let config: ProjectConfig;
+  if (cliInput.yes) {
+    const flagConfig = processProvidedFlagsWithoutValidation(cliInput, finalBaseName);
+
+    config = {
+      ...getDefaultConfig(),
+      ...flagConfig,
+      projectName: finalBaseName,
+      projectDir: finalResolvedPath,
+      relativePath: finalPathInput,
+    };
+
+    validateConfigCompatibility(config, providedFlags, cliInput);
+
+    log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
+    log.message(displayConfig(config));
+  } else {
+    const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
+    const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
+
+    if (Object.keys(otherFlags).length > 0) {
+      log.info(pc.yellow("Using these pre-selected options:"));
+      log.message(displayConfig(otherFlags));
+      log.message("");
+    }
+
+    config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+  }
+
+  await createProject(config, {
+    manualDb: cliInput.manualDb ?? input.manualDb,
+  });
+
+  const reproducibleCommand = generateReproducibleCommand(config);
+  log.success(
+    pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`),
+  );
+
+  await trackProjectCreation(config, input.disableAnalytics);
+
+  const elapsedTimeMs = Date.now() - startTime;
+  const elapsedTimeInSeconds = (elapsedTimeMs / 1000).toFixed(2);
+  outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
+
+  return {
+    success: true,
+    projectConfig: config,
+    reproducibleCommand,
+    timeScaffolded,
+    elapsedTimeMs,
+    projectDirectory: config.projectDir,
+    relativePath: config.relativePath,
+  };
+}
+
+async function handleDirectoryConflictProgrammatically(
+  currentPathInput: string,
+  strategy: DirectoryConflict,
+) {
+  const currentPath = path.resolve(process.cwd(), currentPathInput);
+
+  if (!(await fs.pathExists(currentPath))) {
+    return { finalPathInput: currentPathInput, shouldClearDirectory: false };
+  }
+
+  const dirContents = await fs.readdir(currentPath);
+  const isNotEmpty = dirContents.length > 0;
+
+  if (!isNotEmpty) {
+    return { finalPathInput: currentPathInput, shouldClearDirectory: false };
+  }
+
+  switch (strategy) {
+    case "overwrite":
+      return { finalPathInput: currentPathInput, shouldClearDirectory: true };
+
+    case "merge":
+      return { finalPathInput: currentPathInput, shouldClearDirectory: false };
+
+    case "increment": {
+      let counter = 1;
+      const baseName = currentPathInput;
+      let finalPathInput = `${baseName}-${counter}`;
+
+      while (
+        (await fs.pathExists(path.resolve(process.cwd(), finalPathInput))) &&
+        (await fs.readdir(path.resolve(process.cwd(), finalPathInput))).length > 0
+      ) {
+        counter++;
+        finalPathInput = `${baseName}-${counter}`;
+      }
+
+      return { finalPathInput, shouldClearDirectory: false };
+    }
+
+    case "error":
+      throw new Error(
+        `Directory "${currentPathInput}" already exists and is not empty. Use directoryConflict: "overwrite", "merge", or "increment" to handle this.`,
+      );
+
+    default:
+      throw new Error(`Unknown directory conflict strategy: ${strategy}`);
+  }
+}
+
+export async function addAddonsHandler(input: AddInput) {
+  try {
+    const projectDir = input.projectDir || process.cwd();
+    const detectedConfig = await detectProjectConfig(projectDir);
+
+    if (!detectedConfig) {
+      exitWithError(
+        "Could not detect project configuration. Please ensure this is a valid Better-T-Stack project.",
+      );
+    }
+
+    if (!input.addons || input.addons.length === 0) {
+      const addonsPrompt = await getAddonsToAdd(
+        detectedConfig.frontend || [],
+        detectedConfig.addons || [],
+        detectedConfig.auth,
+      );
+
+      if (addonsPrompt.length > 0) {
+        input.addons = addonsPrompt;
+      }
+    }
+
+    if (!input.webDeploy) {
+      const deploymentPrompt = await getDeploymentToAdd(
+        detectedConfig.frontend || [],
+        detectedConfig.webDeploy,
+      );
+
+      if (deploymentPrompt !== "none") {
+        input.webDeploy = deploymentPrompt;
+      }
+    }
+
+    if (!input.serverDeploy) {
+      const serverDeploymentPrompt = await getServerDeploymentToAdd(
+        detectedConfig.runtime,
+        detectedConfig.serverDeploy,
+        detectedConfig.backend,
+      );
+
+      if (serverDeploymentPrompt !== "none") {
+        input.serverDeploy = serverDeploymentPrompt;
+      }
+    }
+
+    const packageManager = input.packageManager || detectedConfig.packageManager || "npm";
+
+    let somethingAdded = false;
+
+    if (input.addons && input.addons.length > 0) {
+      await addAddonsToProject({
+        ...input,
+        install: false,
+        suppressInstallMessage: true,
+        addons: input.addons,
+      });
+      somethingAdded = true;
+    }
+
+    if (input.webDeploy && input.webDeploy !== "none") {
+      await addDeploymentToProject({
+        ...input,
+        install: false,
+        suppressInstallMessage: true,
+        webDeploy: input.webDeploy,
+      });
+      somethingAdded = true;
+    }
+
+    if (input.serverDeploy && input.serverDeploy !== "none") {
+      await addDeploymentToProject({
+        ...input,
+        install: false,
+        suppressInstallMessage: true,
+        serverDeploy: input.serverDeploy,
+      });
+      somethingAdded = true;
+    }
+
+    if (!somethingAdded) {
+      outro(pc.yellow("No addons or deployment configurations to add."));
+      return;
+    }
+
+    if (input.install) {
+      await installDependencies({
+        projectDir,
+        packageManager,
+      });
+    } else {
+      log.info(`Run ${pc.bold(`${packageManager} install`)} to install dependencies`);
+    }
+
+    outro("Add command completed successfully!");
+  } catch (error) {
+    handleError(error, "Failed to add addons or deployment");
+  }
+}

package/src/helpers/core/convex-codegen.ts

@@ -0,0 +1,14 @@
+import path from "node:path";
+import { $ } from "bun";
+import type { PackageManager } from "../../types";
+import { getPackageExecutionCommand } from "../../utils/package-runner";
+
+// having problems running this in convex + better-auth
+export async function runConvexCodegen(
+  projectDir: string,
+  packageManager: PackageManager | null | undefined,
+) {
+  const backendDir = path.join(projectDir, "packages/backend");
+  const cmd = getPackageExecutionCommand(packageManager, "convex codegen");
+  await $`${{ raw: cmd }}`.cwd(backendDir);
+}