create-better-t-stack 3.7.3-canary.7cbb05fc → 3.7.3-canary.8e4d5716

package/src/utils/generate-reproducible-command.ts

@@ -0,0 +1,53 @@
+import type { ProjectConfig } from "../types";
+
+export function generateReproducibleCommand(config: ProjectConfig) {
+  const flags: string[] = [];
+
+  if (config.frontend && config.frontend.length > 0) {
+    flags.push(`--frontend ${config.frontend.join(" ")}`);
+  } else {
+    flags.push("--frontend none");
+  }
+
+  flags.push(`--backend ${config.backend}`);
+  flags.push(`--runtime ${config.runtime}`);
+  flags.push(`--database ${config.database}`);
+  flags.push(`--orm ${config.orm}`);
+  flags.push(`--api ${config.api}`);
+  flags.push(`--auth ${config.auth}`);
+  flags.push(`--payments ${config.payments}`);
+
+  if (config.addons && config.addons.length > 0) {
+    flags.push(`--addons ${config.addons.join(" ")}`);
+  } else {
+    flags.push("--addons none");
+  }
+
+  if (config.examples && config.examples.length > 0) {
+    flags.push(`--examples ${config.examples.join(" ")}`);
+  } else {
+    flags.push("--examples none");
+  }
+
+  flags.push(`--db-setup ${config.dbSetup}`);
+  flags.push(`--web-deploy ${config.webDeploy}`);
+  flags.push(`--server-deploy ${config.serverDeploy}`);
+  flags.push(config.git ? "--git" : "--no-git");
+  flags.push(`--package-manager ${config.packageManager}`);
+  flags.push(config.install ? "--install" : "--no-install");
+
+  let baseCommand = "npx create-better-t-stack@latest";
+  const pkgManager = config.packageManager;
+
+  if (pkgManager === "bun") {
+    baseCommand = "bun create better-t-stack@latest";
+  } else if (pkgManager === "pnpm") {
+    baseCommand = "pnpm create better-t-stack@latest";
+  } else if (pkgManager === "npm") {
+    baseCommand = "npx create-better-t-stack@latest";
+  }
+
+  const projectPathArg = config.relativePath ? ` ${config.relativePath}` : "";
+
+  return `${baseCommand}${projectPathArg} ${flags.join(" ")}`;
+}

package/src/utils/get-latest-cli-version.ts

@@ -0,0 +1,11 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { PKG_ROOT } from "../constants";
+
+export const getLatestCLIVersion = () => {
+  const packageJsonPath = path.join(PKG_ROOT, "package.json");
+
+  const packageJsonContent = fs.readJSONSync(packageJsonPath);
+
+  return packageJsonContent.version ?? "1.0.0";
+};

package/src/utils/get-package-manager.ts

@@ -0,0 +1,13 @@
+import type { PackageManager } from "../types";
+
+export const getUserPkgManager: () => PackageManager = () => {
+  const userAgent = process.env.npm_config_user_agent;
+
+  if (userAgent?.startsWith("pnpm")) {
+    return "pnpm";
+  }
+  if (userAgent?.startsWith("bun")) {
+    return "bun";
+  }
+  return "npm";
+};

package/src/utils/open-url.ts

@@ -0,0 +1,25 @@
+import { log } from "@clack/prompts";
+import { execa } from "execa";
+
+export async function openUrl(url: string) {
+  const platform = process.platform;
+  let command: string;
+  let args: string[] = [];
+
+  if (platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url.replace(/&/g, "^&")];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+
+  try {
+    await execa(command, args, { stdio: "ignore" });
+  } catch {
+    log.message(`Please open ${url} in your browser.`);
+  }
+}

package/src/utils/package-runner.ts

@@ -0,0 +1,23 @@
+import type { PackageManager } from "../types";
+
+/**
+ * Returns the appropriate command for running a package without installing it globally,
+ * based on the selected package manager.
+ *
+ * @param packageManager - The selected package manager (e.g., 'npm', 'yarn', 'pnpm', 'bun').
+ * @param commandWithArgs - The command to run, including arguments (e.g., "prisma generate --schema=./prisma/schema.prisma").
+ * @returns The full command string (e.g., "npx prisma generate --schema=./prisma/schema.prisma").
+ */
+export function getPackageExecutionCommand(
+  packageManager: PackageManager | null | undefined,
+  commandWithArgs: string,
+) {
+  switch (packageManager) {
+    case "pnpm":
+      return `pnpm dlx ${commandWithArgs}`;
+    case "bun":
+      return `bunx ${commandWithArgs}`;
+    default:
+      return `npx ${commandWithArgs}`;
+  }
+}

package/src/utils/project-directory.ts

@@ -0,0 +1,102 @@
+import path from "node:path";
+import { isCancel, log, select, spinner } from "@clack/prompts";
+import fs from "fs-extra";
+import pc from "picocolors";
+import { getProjectName } from "../prompts/project-name";
+import { exitCancelled, handleError } from "./errors";
+
+export async function handleDirectoryConflict(currentPathInput: string, silent = false) {
+  while (true) {
+    const resolvedPath = path.resolve(process.cwd(), currentPathInput);
+    const dirExists = await fs.pathExists(resolvedPath);
+    const dirIsNotEmpty = dirExists && (await fs.readdir(resolvedPath)).length > 0;
+
+    if (!dirIsNotEmpty) {
+      return { finalPathInput: currentPathInput, shouldClearDirectory: false };
+    }
+
+    if (silent) {
+      throw new Error(
+        `Directory "${currentPathInput}" already exists and is not empty. In silent mode, please provide a different project name or clear the directory manually.`,
+      );
+    }
+
+    log.warn(`Directory "${pc.yellow(currentPathInput)}" already exists and is not empty.`);
+
+    const action = await select<"overwrite" | "merge" | "rename" | "cancel">({
+      message: "What would you like to do?",
+      options: [
+        {
+          value: "overwrite",
+          label: "Overwrite",
+          hint: "Empty the directory and create the project",
+        },
+        {
+          value: "merge",
+          label: "Merge",
+          hint: "Create project files inside, potentially overwriting conflicts",
+        },
+        {
+          value: "rename",
+          label: "Choose a different name/path",
+          hint: "Keep the existing directory and create a new one",
+        },
+        { value: "cancel", label: "Cancel", hint: "Abort the process" },
+      ],
+      initialValue: "rename",
+    });
+
+    if (isCancel(action)) return exitCancelled("Operation cancelled.");
+
+    switch (action) {
+      case "overwrite":
+        return { finalPathInput: currentPathInput, shouldClearDirectory: true };
+      case "merge":
+        log.info(
+          `Proceeding into existing directory "${pc.yellow(
+            currentPathInput,
+          )}". Files may be overwritten.`,
+        );
+        return {
+          finalPathInput: currentPathInput,
+          shouldClearDirectory: false,
+        };
+      case "rename": {
+        log.info("Please choose a different project name or path.");
+        const newPathInput = await getProjectName(undefined);
+        return await handleDirectoryConflict(newPathInput);
+      }
+      case "cancel":
+        return exitCancelled("Operation cancelled.");
+    }
+  }
+}
+
+export async function setupProjectDirectory(finalPathInput: string, shouldClearDirectory: boolean) {
+  let finalResolvedPath: string;
+  let finalBaseName: string;
+
+  if (finalPathInput === ".") {
+    finalResolvedPath = process.cwd();
+    finalBaseName = path.basename(finalResolvedPath);
+  } else {
+    finalResolvedPath = path.resolve(process.cwd(), finalPathInput);
+    finalBaseName = path.basename(finalResolvedPath);
+  }
+
+  if (shouldClearDirectory) {
+    const s = spinner();
+    s.start(`Clearing directory "${finalResolvedPath}"...`);
+    try {
+      await fs.emptyDir(finalResolvedPath);
+      s.stop(`Directory "${finalResolvedPath}" cleared.`);
+    } catch (error) {
+      s.stop(pc.red(`Failed to clear directory "${finalResolvedPath}".`));
+      handleError(error);
+    }
+  } else {
+    await fs.ensureDir(finalResolvedPath);
+  }
+
+  return { finalResolvedPath, finalBaseName };
+}

package/src/utils/project-name-validation.ts

@@ -0,0 +1,43 @@
+import path from "node:path";
+import { ProjectNameSchema } from "../types";
+import { exitWithError } from "./errors";
+
+export function validateProjectName(name: string) {
+  const result = ProjectNameSchema.safeParse(name);
+  if (!result.success) {
+    exitWithError(
+      `Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`,
+    );
+  }
+}
+
+export function validateProjectNameThrow(name: string) {
+  const result = ProjectNameSchema.safeParse(name);
+  if (!result.success) {
+    throw new Error(`Invalid project name: ${result.error.issues[0]?.message}`);
+  }
+}
+
+export function extractAndValidateProjectName(
+  projectName?: string,
+  projectDirectory?: string,
+  throwOnError = false,
+) {
+  const derivedName =
+    projectName ||
+    (projectDirectory ? path.basename(path.resolve(process.cwd(), projectDirectory)) : "");
+
+  if (!derivedName) {
+    return "";
+  }
+
+  const nameToValidate = projectName ? path.basename(projectName) : derivedName;
+
+  if (throwOnError) {
+    validateProjectNameThrow(nameToValidate);
+  } else {
+    validateProjectName(nameToValidate);
+  }
+
+  return projectName || derivedName;
+}

package/src/utils/render-title.ts

@@ -0,0 +1,48 @@
+import gradient from "gradient-string";
+
+export const TITLE_TEXT = `
+ ██████╗ ███████╗████████╗████████╗███████╗██████╗
+ ██╔══██╗██╔════╝╚══██╔══╝╚══██╔══╝██╔════╝██╔══██╗
+ ██████╔╝█████╗     ██║      ██║   █████╗  ██████╔╝
+ ██╔══██╗██╔══╝     ██║      ██║   ██╔══╝  ██╔══██╗
+ ██████╔╝███████╗   ██║      ██║   ███████╗██║  ██║
+ ╚═════╝ ╚══════╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═╝
+
+ ████████╗    ███████╗████████╗ █████╗  ██████╗██╗  ██╗
+ ╚══██╔══╝    ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
+    ██║       ███████╗   ██║   ███████║██║     █████╔╝
+    ██║       ╚════██║   ██║   ██╔══██║██║     ██╔═██╗
+    ██║       ███████║   ██║   ██║  ██║╚██████╗██║  ██╗
+    ╚═╝       ╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
+ `;
+
+const catppuccinTheme = {
+  pink: "#F5C2E7",
+  mauve: "#CBA6F7",
+  red: "#F38BA8",
+  maroon: "#E78284",
+  peach: "#FAB387",
+  yellow: "#F9E2AF",
+  green: "#A6E3A1",
+  teal: "#94E2D5",
+  sky: "#89DCEB",
+  sapphire: "#74C7EC",
+  lavender: "#B4BEFE",
+};
+
+export const renderTitle = () => {
+  const terminalWidth = process.stdout.columns || 80;
+  const titleLines = TITLE_TEXT.split("\n");
+  const titleWidth = Math.max(...titleLines.map((line) => line.length));
+
+  if (terminalWidth < titleWidth) {
+    const simplifiedTitle = `
+    ╔══════════════════╗
+    ║  Better T Stack  ║
+    ╚══════════════════╝
+    `;
+    console.log(gradient(Object.values(catppuccinTheme)).multiline(simplifiedTitle));
+  } else {
+    console.log(gradient(Object.values(catppuccinTheme)).multiline(TITLE_TEXT));
+  }
+};

package/src/utils/setup-catalogs.ts

@@ -0,0 +1,192 @@
+import path from "node:path";
+import fs from "fs-extra";
+import yaml from "yaml";
+import type { ProjectConfig } from "../types";
+
+type PackageInfo = {
+  path: string;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+};
+
+type CatalogEntry = {
+  versions: Set<string>;
+  packages: string[];
+};
+
+export async function setupCatalogs(projectDir: string, options: ProjectConfig) {
+  if (options.packageManager === "npm") {
+    return;
+  }
+
+  const packagePaths = [
+    ".", // root monorepo
+    "apps/server",
+    "apps/web",
+    "apps/native",
+    "apps/fumadocs",
+    "apps/docs",
+    "packages/api",
+    "packages/db",
+    "packages/auth",
+    "packages/backend",
+    "packages/config",
+  ];
+
+  const packagesInfo: PackageInfo[] = [];
+
+  for (const pkgPath of packagePaths) {
+    const fullPath = path.join(projectDir, pkgPath);
+    const pkgJsonPath = path.join(fullPath, "package.json");
+
+    if (await fs.pathExists(pkgJsonPath)) {
+      const pkgJson = await fs.readJson(pkgJsonPath);
+      packagesInfo.push({
+        path: fullPath,
+        dependencies: pkgJson.dependencies || {},
+        devDependencies: pkgJson.devDependencies || {},
+      });
+    }
+  }
+
+  const catalog = findDuplicateDependencies(packagesInfo, options.projectName);
+
+  if (Object.keys(catalog).length === 0) {
+    return;
+  }
+
+  if (options.packageManager === "bun") {
+    await setupBunCatalogs(projectDir, catalog);
+  } else if (options.packageManager === "pnpm") {
+    await setupPnpmCatalogs(projectDir, catalog);
+  }
+
+  await updatePackageJsonsWithCatalogs(packagesInfo, catalog);
+}
+
+function findDuplicateDependencies(
+  packagesInfo: PackageInfo[],
+  projectName: string,
+): Record<string, string> {
+  const depCount = new Map<string, CatalogEntry>();
+  const projectScope = `@${projectName}/`;
+
+  for (const pkg of packagesInfo) {
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+
+    for (const [depName, version] of Object.entries(allDeps)) {
+      if (depName.startsWith(projectScope)) {
+        continue;
+      }
+
+      if (version.startsWith("workspace:")) {
+        continue;
+      }
+
+      const existing = depCount.get(depName);
+      if (existing) {
+        existing.versions.add(version);
+        existing.packages.push(pkg.path);
+      } else {
+        depCount.set(depName, {
+          versions: new Set([version]),
+          packages: [pkg.path],
+        });
+      }
+    }
+  }
+
+  const catalog: Record<string, string> = {};
+  for (const [depName, info] of depCount.entries()) {
+    if (info.packages.length > 1 && info.versions.size === 1) {
+      catalog[depName] = Array.from(info.versions)[0];
+    }
+  }
+
+  return catalog;
+}
+
+async function setupBunCatalogs(projectDir: string, catalog: Record<string, string>) {
+  const rootPkgJsonPath = path.join(projectDir, "package.json");
+  const rootPkgJson = await fs.readJson(rootPkgJsonPath);
+
+  if (!rootPkgJson.workspaces) {
+    rootPkgJson.workspaces = {};
+  }
+
+  if (Array.isArray(rootPkgJson.workspaces)) {
+    rootPkgJson.workspaces = {
+      packages: rootPkgJson.workspaces,
+      catalog,
+    };
+  } else if (typeof rootPkgJson.workspaces === "object") {
+    if (!rootPkgJson.workspaces.catalog) {
+      rootPkgJson.workspaces.catalog = {};
+    }
+    rootPkgJson.workspaces.catalog = {
+      ...rootPkgJson.workspaces.catalog,
+      ...catalog,
+    };
+  }
+
+  await fs.writeJson(rootPkgJsonPath, rootPkgJson, { spaces: 2 });
+}
+
+async function setupPnpmCatalogs(projectDir: string, catalog: Record<string, string>) {
+  const workspaceYamlPath = path.join(projectDir, "pnpm-workspace.yaml");
+
+  if (!(await fs.pathExists(workspaceYamlPath))) {
+    return;
+  }
+
+  const workspaceContent = await fs.readFile(workspaceYamlPath, "utf-8");
+  const workspaceYaml = yaml.parse(workspaceContent);
+
+  if (!workspaceYaml.catalog) {
+    workspaceYaml.catalog = {};
+  }
+
+  workspaceYaml.catalog = {
+    ...workspaceYaml.catalog,
+    ...catalog,
+  };
+
+  await fs.writeFile(workspaceYamlPath, yaml.stringify(workspaceYaml));
+}
+
+async function updatePackageJsonsWithCatalogs(
+  packagesInfo: PackageInfo[],
+  catalog: Record<string, string>,
+) {
+  for (const pkg of packagesInfo) {
+    const pkgJsonPath = path.join(pkg.path, "package.json");
+    const pkgJson = await fs.readJson(pkgJsonPath);
+
+    let updated = false;
+
+    if (pkgJson.dependencies) {
+      for (const depName of Object.keys(pkgJson.dependencies)) {
+        if (catalog[depName]) {
+          pkgJson.dependencies[depName] = "catalog:";
+          updated = true;
+        }
+      }
+    }
+
+    if (pkgJson.devDependencies) {
+      for (const depName of Object.keys(pkgJson.devDependencies)) {
+        if (catalog[depName]) {
+          pkgJson.devDependencies[depName] = "catalog:";
+          updated = true;
+        }
+      }
+    }
+
+    if (updated) {
+      await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+    }
+  }
+}

package/src/utils/sponsors.ts

@@ -0,0 +1,101 @@
+import { log, outro, spinner } from "@clack/prompts";
+import { consola } from "consola";
+import pc from "picocolors";
+
+type SponsorSummary = {
+  total_sponsors: number;
+  total_lifetime_amount: number;
+  total_current_monthly: number;
+  special_sponsors: number;
+  current_sponsors: number;
+  past_sponsors: number;
+  backers: number;
+  top_sponsor?: {
+    name: string;
+    amount: number;
+  };
+};
+
+type Sponsor = {
+  name?: string;
+  githubId: string;
+  avatarUrl: string;
+  websiteUrl?: string;
+  githubUrl: string;
+  tierName?: string;
+  sinceWhen: string;
+  transactionCount: number;
+  totalProcessedAmount?: number;
+  formattedAmount?: string;
+};
+
+type SponsorEntry = {
+  generated_at: string;
+  summary: SponsorSummary;
+  specialSponsors: Sponsor[];
+  sponsors: Sponsor[];
+  pastSponsors: Sponsor[];
+  backers: Sponsor[];
+};
+
+export const SPONSORS_JSON_URL = "https://sponsors.better-t-stack.dev/sponsors.json";
+
+export async function fetchSponsors(url: string = SPONSORS_JSON_URL) {
+  const s = spinner();
+  s.start("Fetching sponsors…");
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    s.stop(pc.red(`Failed to fetch sponsors: ${response.statusText}`));
+    throw new Error(`Failed to fetch sponsors: ${response.statusText}`);
+  }
+
+  const sponsors = (await response.json()) as SponsorEntry;
+  s.stop("Sponsors fetched successfully!");
+  return sponsors;
+}
+
+export function displaySponsors(sponsors: SponsorEntry) {
+  const { total_sponsors } = sponsors.summary;
+  if (total_sponsors === 0) {
+    log.info("No sponsors found. You can be the first one! ✨");
+    outro(pc.cyan("Visit https://github.com/sponsors/AmanVarshney01 to become a sponsor."));
+    return;
+  }
+
+  displaySponsorsBox(sponsors);
+
+  if (total_sponsors - sponsors.specialSponsors.length > 0) {
+    log.message(
+      pc.blue(`+${total_sponsors - sponsors.specialSponsors.length} more amazing sponsors.\n`),
+    );
+  }
+  outro(pc.magenta("Visit https://github.com/sponsors/AmanVarshney01 to become a sponsor."));
+}
+
+function displaySponsorsBox(sponsors: SponsorEntry) {
+  if (sponsors.specialSponsors.length === 0) {
+    return;
+  }
+
+  let output = `${pc.bold(pc.cyan("-> Special Sponsors"))}\n\n`;
+
+  sponsors.specialSponsors.forEach((sponsor: Sponsor, idx: number) => {
+    const displayName = sponsor.name ?? sponsor.githubId;
+    const tier = sponsor.tierName ? ` ${pc.yellow(`(${sponsor.tierName})`)}` : "";
+
+    output += `${pc.green(`• ${displayName}`)}${tier}\n`;
+    output += `  ${pc.dim("GitHub:")} https://github.com/${sponsor.githubId}\n`;
+
+    const website = sponsor.websiteUrl ?? sponsor.githubUrl;
+    if (website) {
+      output += `  ${pc.dim("Website:")} ${website}\n`;
+    }
+
+    if (idx < sponsors.specialSponsors.length - 1) {
+      output += "\n";
+    }
+  });
+
+  consola.box(output);
+}

package/src/utils/telemetry.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns true if telemetry/analytics should be enabled, false otherwise.
+ *
+ * - If BTS_TELEMETRY_DISABLED is present and "1", disables analytics.
+ * - Otherwise, BTS_TELEMETRY: "0" disables, "1" enables (default: enabled).
+ */
+export function isTelemetryEnabled() {
+  const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
+  const BTS_TELEMETRY = process.env.BTS_TELEMETRY;
+
+  if (BTS_TELEMETRY_DISABLED !== undefined) {
+    return BTS_TELEMETRY_DISABLED !== "1";
+  }
+  if (BTS_TELEMETRY !== undefined) {
+    return BTS_TELEMETRY === "1";
+  }
+  // Default: enabled
+  return true;
+}