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

package/src/utils/add-package-deps.ts

@@ -0,0 +1,57 @@
+import path from "node:path";
+import fs from "fs-extra";
+
+import { type AvailableDependencies, dependencyVersionMap } from "../constants";
+
+export const addPackageDependency = async (opts: {
+  dependencies?: AvailableDependencies[];
+  devDependencies?: AvailableDependencies[];
+  customDependencies?: Record<string, string>;
+  customDevDependencies?: Record<string, string>;
+  projectDir: string;
+}) => {
+  const {
+    dependencies = [],
+    devDependencies = [],
+    customDependencies = {},
+    customDevDependencies = {},
+    projectDir,
+  } = opts;
+
+  const pkgJsonPath = path.join(projectDir, "package.json");
+
+  const pkgJson = await fs.readJson(pkgJsonPath);
+
+  if (!pkgJson.dependencies) pkgJson.dependencies = {};
+  if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
+
+  for (const pkgName of dependencies) {
+    const version = dependencyVersionMap[pkgName];
+    if (version) {
+      pkgJson.dependencies[pkgName] = version;
+    } else {
+      console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
+    }
+  }
+
+  for (const pkgName of devDependencies) {
+    const version = dependencyVersionMap[pkgName];
+    if (version) {
+      pkgJson.devDependencies[pkgName] = version;
+    } else {
+      console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
+    }
+  }
+
+  for (const [pkgName, version] of Object.entries(customDependencies)) {
+    pkgJson.dependencies[pkgName] = version;
+  }
+
+  for (const [pkgName, version] of Object.entries(customDevDependencies)) {
+    pkgJson.devDependencies[pkgName] = version;
+  }
+
+  await fs.writeJson(pkgJsonPath, pkgJson, {
+    spaces: 2,
+  });
+};

package/src/utils/analytics.ts

@@ -0,0 +1,39 @@
+import type { ProjectConfig } from "../types";
+import { getLatestCLIVersion } from "./get-latest-cli-version";
+import { isTelemetryEnabled } from "./telemetry";
+
+const CONVEX_INGEST_URL = "https://striped-seahorse-863.convex.site/api/analytics/ingest";
+
+async function sendConvexEvent(payload: Record<string, unknown>) {
+  if (!CONVEX_INGEST_URL) return;
+
+  try {
+    await fetch(CONVEX_INGEST_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+  } catch {}
+}
+
+export async function trackProjectCreation(config: ProjectConfig, disableAnalytics = false) {
+  if (!isTelemetryEnabled() || disableAnalytics) return;
+
+  const {
+    projectName: _projectName,
+    projectDir: _projectDir,
+    relativePath: _relativePath,
+    ...safeConfig
+  } = config;
+
+  try {
+    await sendConvexEvent({
+      ...safeConfig,
+      cli_version: getLatestCLIVersion(),
+      node_version: typeof process !== "undefined" ? process.version : "",
+      platform: typeof process !== "undefined" ? process.platform : "",
+    });
+  } catch {}
+}

package/src/utils/better-auth-plugin-setup.ts

@@ -0,0 +1,71 @@
+import { SyntaxKind } from "ts-morph";
+import type { ProjectConfig } from "../types";
+import { ensureArrayProperty, tsProject } from "./ts-morph";
+
+export async function setupBetterAuthPlugins(projectDir: string, config: ProjectConfig) {
+  const authIndexPath = `${projectDir}/packages/auth/src/index.ts`;
+  const authIndexFile = tsProject.addSourceFileAtPath(authIndexPath);
+
+  if (!authIndexFile) {
+    return;
+  }
+
+  const pluginsToAdd: string[] = [];
+  const importsToAdd: string[] = [];
+
+  if (config.backend === "self" && config.frontend?.includes("tanstack-start")) {
+    pluginsToAdd.push("tanstackStartCookies()");
+    importsToAdd.push('import { tanstackStartCookies } from "better-auth/tanstack-start";');
+  }
+
+  if (config.backend === "self" && config.frontend?.includes("next")) {
+    pluginsToAdd.push("nextCookies()");
+    importsToAdd.push('import { nextCookies } from "better-auth/next-js";');
+  }
+
+  if (
+    config.frontend?.includes("native-bare") ||
+    config.frontend?.includes("native-uniwind") ||
+    config.frontend?.includes("native-unistyles")
+  ) {
+    pluginsToAdd.push("expo()");
+    importsToAdd.push('import { expo } from "@better-auth/expo";');
+  }
+
+  if (pluginsToAdd.length === 0) {
+    return;
+  }
+
+  importsToAdd.forEach((importStatement) => {
+    const existingImport = authIndexFile.getImportDeclaration((declaration) =>
+      declaration.getModuleSpecifierValue().includes(importStatement.split('"')[1]),
+    );
+
+    if (!existingImport) {
+      authIndexFile.insertImportDeclaration(0, {
+        moduleSpecifier: importStatement.split('"')[1],
+        namedImports: [importStatement.split("{")[1].split("}")[0].trim()],
+      });
+    }
+  });
+
+  const betterAuthCall = authIndexFile
+    .getDescendantsOfKind(SyntaxKind.CallExpression)
+    .find((call) => call.getExpression().getText() === "betterAuth");
+
+  if (betterAuthCall) {
+    const configObject = betterAuthCall.getArguments()[0];
+
+    if (configObject && configObject.getKind() === SyntaxKind.ObjectLiteralExpression) {
+      const objLiteral = configObject.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+
+      const pluginsArray = ensureArrayProperty(objLiteral, "plugins");
+
+      pluginsToAdd.forEach((plugin) => {
+        pluginsArray.addElement(plugin);
+      });
+    }
+  }
+
+  authIndexFile.save();
+}

package/src/utils/biome-formatter.ts

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { Biome } from "@biomejs/js-api/nodejs";
+import consola from "consola";
+
+function initializeBiome() {
+  try {
+    const biome = new Biome();
+    const result = biome.openProject("./");
+    const projectKey = result.projectKey;
+
+    biome.applyConfiguration(projectKey, {
+      formatter: {
+        enabled: true,
+        indentStyle: "tab",
+        indentWidth: 2,
+        lineWidth: 80,
+      },
+      linter: {
+        enabled: false,
+      },
+      javascript: {
+        formatter: {
+          enabled: true,
+        },
+      },
+      json: {
+        formatter: {
+          enabled: true,
+        },
+      },
+    });
+
+    return { biome, projectKey };
+  } catch {
+    return null;
+  }
+}
+
+function isSupportedFile(filePath: string) {
+  const ext = path.extname(filePath).toLowerCase();
+  const supportedExtensions = [".js", ".jsx", ".ts", ".tsx", ".json", ".jsonc"];
+  return supportedExtensions.includes(ext);
+}
+
+function shouldSkipFile(filePath: string) {
+  const basename = path.basename(filePath);
+  const skipPatterns = [
+    ".hbs",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    ".d.ts",
+  ];
+
+  return skipPatterns.some((pattern) => basename.includes(pattern));
+}
+
+export function formatFileWithBiome(filePath: string, content: string) {
+  if (!isSupportedFile(filePath) || shouldSkipFile(filePath)) {
+    return null;
+  }
+
+  try {
+    const biomeResult = initializeBiome();
+    if (!biomeResult) return null;
+
+    const { biome, projectKey } = biomeResult;
+
+    const result = biome.formatContent(projectKey, content, {
+      filePath: path.basename(filePath),
+    });
+
+    if (result.diagnostics && result.diagnostics.length > 0) {
+      consola.debug(`Biome formatting diagnostics for ${filePath}:`, result.diagnostics);
+    }
+
+    return result.content;
+  } catch {
+    return null;
+  }
+}

package/src/utils/bts-config.ts

@@ -0,0 +1,122 @@
+import path from "node:path";
+import fs from "fs-extra";
+import * as JSONC from "jsonc-parser";
+import type { BetterTStackConfig, ProjectConfig } from "../types";
+import { getLatestCLIVersion } from "./get-latest-cli-version";
+
+const BTS_CONFIG_FILE = "bts.jsonc";
+
+export async function writeBtsConfig(projectConfig: ProjectConfig) {
+  const btsConfig: BetterTStackConfig = {
+    version: getLatestCLIVersion(),
+    createdAt: new Date().toISOString(),
+    database: projectConfig.database,
+    orm: projectConfig.orm,
+    backend: projectConfig.backend,
+    runtime: projectConfig.runtime,
+    frontend: projectConfig.frontend,
+    addons: projectConfig.addons,
+    examples: projectConfig.examples,
+    auth: projectConfig.auth,
+    payments: projectConfig.payments,
+    packageManager: projectConfig.packageManager,
+    dbSetup: projectConfig.dbSetup,
+    api: projectConfig.api,
+    webDeploy: projectConfig.webDeploy,
+    serverDeploy: projectConfig.serverDeploy,
+  };
+
+  const baseContent = {
+    $schema: "https://r2.better-t-stack.dev/schema.json",
+    version: btsConfig.version,
+    createdAt: btsConfig.createdAt,
+    database: btsConfig.database,
+    orm: btsConfig.orm,
+    backend: btsConfig.backend,
+    runtime: btsConfig.runtime,
+    frontend: btsConfig.frontend,
+    addons: btsConfig.addons,
+    examples: btsConfig.examples,
+    auth: btsConfig.auth,
+    payments: btsConfig.payments,
+    packageManager: btsConfig.packageManager,
+    dbSetup: btsConfig.dbSetup,
+    api: btsConfig.api,
+    webDeploy: btsConfig.webDeploy,
+    serverDeploy: btsConfig.serverDeploy,
+  };
+
+  let configContent = JSON.stringify(baseContent);
+
+  const formatResult = JSONC.format(configContent, undefined, {
+    tabSize: 2,
+    insertSpaces: true,
+    eol: "\n",
+  });
+
+  configContent = JSONC.applyEdits(configContent, formatResult);
+
+  const finalContent = `// Better-T-Stack configuration file
+// safe to delete
+
+${configContent}`;
+  const configPath = path.join(projectConfig.projectDir, BTS_CONFIG_FILE);
+  await fs.writeFile(configPath, finalContent, "utf-8");
+}
+
+export async function readBtsConfig(projectDir: string) {
+  try {
+    const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+
+    if (!(await fs.pathExists(configPath))) {
+      return null;
+    }
+
+    const configContent = await fs.readFile(configPath, "utf-8");
+
+    const errors: JSONC.ParseError[] = [];
+    const config = JSONC.parse(configContent, errors, {
+      allowTrailingComma: true,
+      disallowComments: false,
+    }) as BetterTStackConfig;
+
+    if (errors.length > 0) {
+      console.warn("Warning: Found errors parsing bts.jsonc:", errors);
+      return null;
+    }
+
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+export async function updateBtsConfig(
+  projectDir: string,
+  updates: Partial<Pick<BetterTStackConfig, "addons" | "webDeploy" | "serverDeploy">>,
+) {
+  try {
+    const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+
+    if (!(await fs.pathExists(configPath))) {
+      return;
+    }
+
+    const configContent = await fs.readFile(configPath, "utf-8");
+
+    let modifiedContent = configContent;
+
+    for (const [key, value] of Object.entries(updates)) {
+      const editResult = JSONC.modify(modifiedContent, [key], value, {
+        formattingOptions: {
+          tabSize: 2,
+          insertSpaces: true,
+          eol: "\n",
+        },
+      });
+      modifiedContent = JSONC.applyEdits(modifiedContent, editResult);
+    }
+
+    await fs.writeFile(configPath, modifiedContent, "utf-8");
+  } catch {}
+}

package/src/utils/command-exists.ts

@@ -0,0 +1,16 @@
+import { execa } from "execa";
+
+export async function commandExists(command: string) {
+  try {
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      const result = await execa("where", [command]);
+      return result.exitCode === 0;
+    }
+
+    const result = await execa("which", [command]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}