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

package/src/helpers/core/add-addons.ts

@@ -0,0 +1,85 @@
+import path from "node:path";
+import { log } from "@clack/prompts";
+import pc from "picocolors";
+import type { AddInput, Addons, ProjectConfig } from "../../types";
+import { updateBtsConfig } from "../../utils/bts-config";
+import { validateAddonCompatibility } from "../../utils/compatibility-rules";
+import { exitWithError } from "../../utils/errors";
+import { setupAddons } from "../addons/addons-setup";
+import { detectProjectConfig, isBetterTStackProject } from "./detect-project-config";
+import { installDependencies } from "./install-dependencies";
+import { setupAddonsTemplate } from "./template-manager";
+
+export async function addAddonsToProject(
+  input: AddInput & { addons: Addons[]; suppressInstallMessage?: boolean },
+) {
+  try {
+    const projectDir = input.projectDir || process.cwd();
+
+    const isBetterTStack = await isBetterTStackProject(projectDir);
+    if (!isBetterTStack) {
+      exitWithError(
+        "This doesn't appear to be a Better-T-Stack project. Please run this command from the root of a Better-T-Stack project.",
+      );
+    }
+
+    const detectedConfig = await detectProjectConfig(projectDir);
+    if (!detectedConfig) {
+      exitWithError(
+        "Could not detect the project configuration. Please ensure this is a valid Better-T-Stack project.",
+      );
+    }
+
+    const config: ProjectConfig = {
+      projectName: detectedConfig.projectName || path.basename(projectDir),
+      projectDir,
+      relativePath: ".",
+      database: detectedConfig.database || "none",
+      orm: detectedConfig.orm || "none",
+      backend: detectedConfig.backend || "none",
+      runtime: detectedConfig.runtime || "none",
+      frontend: detectedConfig.frontend || [],
+      addons: input.addons,
+      examples: detectedConfig.examples || [],
+      auth: detectedConfig.auth || "none",
+      payments: detectedConfig.payments || "none",
+      git: false,
+      packageManager: input.packageManager || detectedConfig.packageManager || "npm",
+      install: input.install || false,
+      dbSetup: detectedConfig.dbSetup || "none",
+      api: detectedConfig.api || "none",
+      webDeploy: detectedConfig.webDeploy || "none",
+      serverDeploy: detectedConfig.serverDeploy || "none",
+    };
+
+    for (const addon of input.addons) {
+      const { isCompatible, reason } = validateAddonCompatibility(addon, config.frontend);
+      if (!isCompatible) {
+        exitWithError(
+          reason || `${addon} addon is not compatible with current frontend configuration`,
+        );
+      }
+    }
+
+    await setupAddonsTemplate(projectDir, config);
+    await setupAddons(config, true);
+
+    const currentAddons = detectedConfig.addons || [];
+    const mergedAddons = [...new Set([...currentAddons, ...input.addons])];
+    await updateBtsConfig(projectDir, { addons: mergedAddons });
+
+    if (config.install) {
+      await installDependencies({
+        projectDir,
+        packageManager: config.packageManager,
+      });
+    } else if (!input.suppressInstallMessage) {
+      log.info(
+        pc.yellow(`Run ${pc.bold(`${config.packageManager} install`)} to install dependencies`),
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(`Error adding addons: ${message}`);
+  }
+}

package/src/helpers/core/add-deployment.ts

@@ -0,0 +1,102 @@
+import path from "node:path";
+import { log } from "@clack/prompts";
+import pc from "picocolors";
+import type { AddInput, ProjectConfig, ServerDeploy, WebDeploy } from "../../types";
+import { updateBtsConfig } from "../../utils/bts-config";
+import { exitWithError } from "../../utils/errors";
+import { setupServerDeploy } from "../deployment/server-deploy-setup";
+import { setupWebDeploy } from "../deployment/web-deploy-setup";
+import { detectProjectConfig, isBetterTStackProject } from "./detect-project-config";
+import { installDependencies } from "./install-dependencies";
+import { setupDeploymentTemplates } from "./template-manager";
+
+export async function addDeploymentToProject(
+  input: AddInput & {
+    webDeploy?: WebDeploy;
+    serverDeploy?: ServerDeploy;
+    suppressInstallMessage?: boolean;
+  },
+) {
+  try {
+    const projectDir = input.projectDir || process.cwd();
+
+    const isBetterTStack = await isBetterTStackProject(projectDir);
+    if (!isBetterTStack) {
+      exitWithError(
+        "This doesn't appear to be a Better-T-Stack project. Please run this command from the root of a Better-T-Stack project.",
+      );
+    }
+
+    const detectedConfig = await detectProjectConfig(projectDir);
+    if (!detectedConfig) {
+      exitWithError(
+        "Could not detect the project configuration. Please ensure this is a valid Better-T-Stack project.",
+      );
+    }
+
+    if (input.webDeploy && detectedConfig.webDeploy === input.webDeploy) {
+      exitWithError(`${input.webDeploy} web deployment is already configured for this project.`);
+    }
+
+    if (input.serverDeploy && detectedConfig.serverDeploy === input.serverDeploy) {
+      exitWithError(
+        `${input.serverDeploy} server deployment is already configured for this project.`,
+      );
+    }
+
+    const config: ProjectConfig = {
+      projectName: detectedConfig.projectName || path.basename(projectDir),
+      projectDir,
+      relativePath: ".",
+      database: detectedConfig.database || "none",
+      orm: detectedConfig.orm || "none",
+      backend: detectedConfig.backend || "none",
+      runtime: detectedConfig.runtime || "none",
+      frontend: detectedConfig.frontend || [],
+      addons: detectedConfig.addons || [],
+      examples: detectedConfig.examples || [],
+      auth: detectedConfig.auth || "none",
+      payments: detectedConfig.payments || "none",
+      git: false,
+      packageManager: input.packageManager || detectedConfig.packageManager || "npm",
+      install: input.install || false,
+      dbSetup: detectedConfig.dbSetup || "none",
+      api: detectedConfig.api || "none",
+      webDeploy: input.webDeploy || detectedConfig.webDeploy || "none",
+      serverDeploy: input.serverDeploy || detectedConfig.serverDeploy || "none",
+    };
+
+    if (input.webDeploy && input.webDeploy !== "none") {
+      log.info(
+        pc.green(`Adding ${input.webDeploy} web deployment to ${config.frontend.join("/")}`),
+      );
+    }
+
+    if (input.serverDeploy && input.serverDeploy !== "none") {
+      log.info(pc.green(`Adding ${input.serverDeploy} server deployment`));
+    }
+
+    await setupDeploymentTemplates(projectDir, config);
+    await setupWebDeploy(config);
+    await setupServerDeploy(config);
+
+    await updateBtsConfig(projectDir, {
+      webDeploy: input.webDeploy || config.webDeploy,
+      serverDeploy: input.serverDeploy || config.serverDeploy,
+    });
+
+    if (config.install) {
+      await installDependencies({
+        projectDir,
+        packageManager: config.packageManager,
+      });
+    } else if (!input.suppressInstallMessage) {
+      log.info(
+        pc.yellow(`Run ${pc.bold(`${config.packageManager} install`)} to install dependencies`),
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithError(`Error adding deployment: ${message}`);
+  }
+}

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

@@ -0,0 +1,280 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { AvailableDependencies } from "../../constants";
+import type { API, Backend, Frontend, ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+
+function getFrontendType(frontend: Frontend[]): {
+  hasReactWeb: boolean;
+  hasNuxtWeb: boolean;
+  hasSvelteWeb: boolean;
+  hasSolidWeb: boolean;
+  hasNative: boolean;
+} {
+  const reactBasedFrontends = ["tanstack-router", "react-router", "tanstack-start", "next"];
+  const nativeFrontends = ["native-bare", "native-uniwind", "native-unistyles"];
+
+  return {
+    hasReactWeb: frontend.some((f) => reactBasedFrontends.includes(f)),
+    hasNuxtWeb: frontend.includes("nuxt"),
+    hasSvelteWeb: frontend.includes("svelte"),
+    hasSolidWeb: frontend.includes("solid"),
+    hasNative: frontend.some((f) => nativeFrontends.includes(f)),
+  };
+}
+
+function getApiDependencies(
+  api: API,
+  frontendType: ReturnType<typeof getFrontendType>,
+  backend: Backend,
+) {
+  const deps: Record<string, { dependencies: string[]; devDependencies?: string[] }> = {};
+
+  if (api === "orpc") {
+    deps.server = {
+      dependencies: ["@orpc/server", "@orpc/client", "@orpc/openapi", "@orpc/zod"],
+    };
+  } else if (api === "trpc") {
+    deps.server = { dependencies: ["@trpc/server", "@trpc/client"] };
+  }
+
+  if (backend !== "self" && backend !== "convex" && backend !== "none") {
+    if (!deps.server) {
+      deps.server = { dependencies: [] };
+    }
+
+    if (backend === "hono") {
+      deps.server.dependencies.push("hono");
+    } else if (backend === "elysia") {
+      deps.server.dependencies.push("elysia");
+    }
+  }
+
+  if (frontendType.hasReactWeb) {
+    if (api === "orpc") {
+      deps.web = {
+        dependencies: ["@orpc/tanstack-query", "@orpc/client", "@orpc/server"],
+      };
+    } else if (api === "trpc") {
+      deps.web = {
+        dependencies: ["@trpc/tanstack-react-query", "@trpc/client", "@trpc/server"],
+      };
+    }
+  } else if (frontendType.hasNuxtWeb && api === "orpc") {
+    deps.web = {
+      dependencies: ["@tanstack/vue-query", "@orpc/tanstack-query", "@orpc/client", "@orpc/server"],
+      devDependencies: ["@tanstack/vue-query-devtools"],
+    };
+  } else if (frontendType.hasSvelteWeb && api === "orpc") {
+    deps.web = {
+      dependencies: [
+        "@orpc/tanstack-query",
+        "@orpc/client",
+        "@orpc/server",
+        "@tanstack/svelte-query",
+      ],
+      devDependencies: ["@tanstack/svelte-query-devtools"],
+    };
+  } else if (frontendType.hasSolidWeb && api === "orpc") {
+    deps.web = {
+      dependencies: [
+        "@orpc/tanstack-query",
+        "@orpc/client",
+        "@orpc/server",
+        "@tanstack/solid-query",
+      ],
+      devDependencies: ["@tanstack/solid-query-devtools", "@tanstack/solid-router-devtools"],
+    };
+  }
+
+  if (api === "trpc") {
+    deps.native = {
+      dependencies: ["@trpc/tanstack-react-query", "@trpc/client", "@trpc/server"],
+    };
+  } else if (api === "orpc") {
+    deps.native = { dependencies: ["@orpc/tanstack-query", "@orpc/client"] };
+  }
+
+  return deps;
+}
+
+function getQueryDependencies(frontend: Frontend[]) {
+  const reactBasedFrontends: Frontend[] = [
+    "react-router",
+    "tanstack-router",
+    "tanstack-start",
+    "next",
+    "native-bare",
+    "native-uniwind",
+    "native-unistyles",
+  ];
+
+  const deps: Record<string, { dependencies: string[]; devDependencies?: string[] }> = {};
+
+  const needsReactQuery = frontend.some((f) => reactBasedFrontends.includes(f));
+  if (needsReactQuery) {
+    const hasReactWeb = frontend.some(
+      (f) =>
+        f !== "native-bare" &&
+        f !== "native-uniwind" &&
+        f !== "native-unistyles" &&
+        reactBasedFrontends.includes(f),
+    );
+    const hasNative =
+      frontend.includes("native-bare") ||
+      frontend.includes("native-uniwind") ||
+      frontend.includes("native-unistyles");
+
+    if (hasReactWeb) {
+      deps.web = {
+        dependencies: ["@tanstack/react-query"],
+        devDependencies: ["@tanstack/react-query-devtools"],
+      };
+    }
+    if (hasNative) {
+      deps.native = { dependencies: ["@tanstack/react-query"] };
+    }
+  }
+
+  if (frontend.includes("solid")) {
+    deps.web = {
+      dependencies: ["@tanstack/solid-query"],
+      devDependencies: ["@tanstack/solid-query-devtools", "@tanstack/solid-router-devtools"],
+    };
+  }
+
+  return deps;
+}
+
+function getConvexDependencies(frontend: Frontend[]) {
+  const deps: Record<string, { dependencies: string[] }> = {
+    web: { dependencies: ["convex"] },
+    native: { dependencies: ["convex"] },
+  };
+
+  if (frontend.includes("tanstack-start")) {
+    deps.web.dependencies.push("@convex-dev/react-query");
+  }
+  if (frontend.includes("svelte")) {
+    deps.web.dependencies.push("convex-svelte");
+  }
+  if (frontend.includes("nuxt")) {
+    deps.web.dependencies.push("convex-nuxt", "convex-vue");
+  }
+
+  return deps;
+}
+
+export async function setupApi(config: ProjectConfig) {
+  const { api, frontend, backend, projectDir } = config;
+  const isConvex = backend === "convex";
+
+  const webDir = path.join(projectDir, "apps/web");
+  const nativeDir = path.join(projectDir, "apps/native");
+  const serverDir = path.join(projectDir, "apps/server");
+
+  const webDirExists = await fs.pathExists(webDir);
+  const nativeDirExists = await fs.pathExists(nativeDir);
+  const _serverDirExists = await fs.pathExists(serverDir);
+
+  const frontendType = getFrontendType(frontend);
+
+  if (!isConvex && api !== "none") {
+    const apiDeps = getApiDependencies(api, frontendType, backend);
+    const apiPackageDir = path.join(projectDir, "packages/api");
+
+    if (apiDeps.server) {
+      await addPackageDependency({
+        dependencies: apiDeps.server.dependencies as AvailableDependencies[],
+        projectDir: apiPackageDir,
+      });
+
+      if (backend === "self" && webDirExists) {
+        await addPackageDependency({
+          dependencies: apiDeps.server.dependencies as AvailableDependencies[],
+          projectDir: webDir,
+        });
+      }
+
+      if (backend === "self") {
+        const frameworkDeps: AvailableDependencies[] = [];
+        if (frontend.includes("next")) {
+          frameworkDeps.push("next");
+        }
+
+        if (frameworkDeps.length > 0) {
+          await addPackageDependency({
+            dependencies: frameworkDeps,
+            projectDir: apiPackageDir,
+          });
+        }
+      }
+    }
+
+    if (config.auth === "better-auth" && (backend === "express" || backend === "fastify")) {
+      await addPackageDependency({
+        dependencies: ["better-auth"],
+        projectDir: apiPackageDir,
+      });
+    }
+
+    if (backend === "express") {
+      await addPackageDependency({
+        devDependencies: ["@types/express"],
+        projectDir: apiPackageDir,
+      });
+    }
+
+    if (webDirExists && apiDeps.web) {
+      await addPackageDependency({
+        dependencies: apiDeps.web.dependencies as AvailableDependencies[],
+        devDependencies: apiDeps.web.devDependencies as AvailableDependencies[],
+        projectDir: webDir,
+      });
+    }
+
+    if (nativeDirExists && apiDeps.native) {
+      await addPackageDependency({
+        dependencies: apiDeps.native.dependencies as AvailableDependencies[],
+        projectDir: nativeDir,
+      });
+    }
+  }
+
+  if (!isConvex) {
+    const queryDeps = getQueryDependencies(frontend);
+
+    if (webDirExists && queryDeps.web) {
+      await addPackageDependency({
+        dependencies: queryDeps.web.dependencies as AvailableDependencies[],
+        devDependencies: queryDeps.web.devDependencies as AvailableDependencies[],
+        projectDir: webDir,
+      });
+    }
+
+    if (nativeDirExists && queryDeps.native) {
+      await addPackageDependency({
+        dependencies: queryDeps.native.dependencies as AvailableDependencies[],
+        projectDir: nativeDir,
+      });
+    }
+  }
+
+  if (isConvex) {
+    const convexDeps = getConvexDependencies(frontend);
+
+    if (webDirExists) {
+      await addPackageDependency({
+        dependencies: convexDeps.web.dependencies as AvailableDependencies[],
+        projectDir: webDir,
+      });
+    }
+
+    if (nativeDirExists) {
+      await addPackageDependency({
+        dependencies: convexDeps.native.dependencies as AvailableDependencies[],
+        projectDir: nativeDir,
+      });
+    }
+  }
+}

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.3.34" },
+            projectDir: convexBackendDir,
+          });
+          if (hasNativeForBA) {
+            await addPackageDependency({
+              dependencies: ["@better-auth/expo"],
+              customDependencies: { "@better-auth/expo": "1.3.34" },
+              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.3.34" },
+              projectDir: clientDir,
+            });
+          } else if (hasTanStackStart) {
+            await addPackageDependency({
+              dependencies: ["better-auth", "@convex-dev/better-auth"],
+              customDependencies: { "better-auth": "1.3.34" },
+              projectDir: clientDir,
+            });
+          } else if (hasViteReactOther) {
+            await addPackageDependency({
+              dependencies: ["better-auth", "@convex-dev/better-auth"],
+              customDependencies: { "better-auth": "1.3.34" },
+              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.3.34",
+              "@better-auth/expo": "1.3.34",
+            },
+            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;
+}