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

package/src/helpers/addons/wxt-setup.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { isCancel, log, select, spinner } from "@clack/prompts";
+import { $ } from "bun";
+import fs from "fs-extra";
+import pc from "picocolors";
+import type { ProjectConfig } from "../../types";
+import { exitCancelled } from "../../utils/errors";
+import { getPackageExecutionCommand } from "../../utils/package-runner";
+
+type WxtTemplate = "vanilla" | "vue" | "react" | "solid" | "svelte";
+
+const TEMPLATES = {
+  vanilla: {
+    label: "Vanilla",
+    hint: "Vanilla JavaScript template",
+  },
+  vue: {
+    label: "Vue",
+    hint: "Vue.js template",
+  },
+  react: {
+    label: "React",
+    hint: "React template",
+  },
+  solid: {
+    label: "Solid",
+    hint: "SolidJS template",
+  },
+  svelte: {
+    label: "Svelte",
+    hint: "Svelte template",
+  },
+} as const;
+
+export async function setupWxt(config: ProjectConfig) {
+  const { packageManager, projectDir } = config;
+
+  try {
+    log.info("Setting up WXT...");
+
+    const template = await select<WxtTemplate>({
+      message: "Choose a template",
+      options: Object.entries(TEMPLATES).map(([key, template]) => ({
+        value: key as WxtTemplate,
+        label: template.label,
+        hint: template.hint,
+      })),
+      initialValue: "react",
+    });
+
+    if (isCancel(template)) return exitCancelled("Operation cancelled");
+
+    const commandWithArgs = `wxt@latest init extension --template ${template} --pm ${packageManager}`;
+
+    const wxtInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+
+    const appsDir = path.join(projectDir, "apps");
+    await fs.ensureDir(appsDir);
+
+    const s = spinner();
+    s.start("Running WXT init command...");
+
+    await $`${{ raw: wxtInitCommand }}`.cwd(appsDir).env({ CI: "true" });
+
+    const extensionDir = path.join(projectDir, "apps", "extension");
+    const packageJsonPath = path.join(extensionDir, "package.json");
+
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.name = "extension";
+
+      if (packageJson.scripts?.dev) {
+        packageJson.scripts.dev = `${packageJson.scripts.dev} --port 5555`;
+      }
+
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+
+    s.stop("WXT setup complete!");
+  } catch (error) {
+    log.error(pc.red("Failed to set up WXT"));
+    if (error instanceof Error) {
+      console.error(pc.red(error.message));
+    }
+  }
+}

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,
+      });
+    }
+  }
+}