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

package/src/types.ts

@@ -0,0 +1,70 @@
+// Re-export everything from the shared types package
+export {
+  // Schemas
+  DatabaseSchema,
+  ORMSchema,
+  BackendSchema,
+  RuntimeSchema,
+  FrontendSchema,
+  AddonsSchema,
+  ExamplesSchema,
+  PackageManagerSchema,
+  DatabaseSetupSchema,
+  APISchema,
+  AuthSchema,
+  PaymentsSchema,
+  WebDeploySchema,
+  ServerDeploySchema,
+  DirectoryConflictSchema,
+  TemplateSchema,
+  ProjectNameSchema,
+  CreateInputSchema,
+  AddInputSchema,
+  CLIInputSchema,
+  ProjectConfigSchema,
+  BetterTStackConfigSchema,
+  InitResultSchema,
+  // Enum value arrays
+  DATABASE_VALUES,
+  ORM_VALUES,
+  BACKEND_VALUES,
+  RUNTIME_VALUES,
+  FRONTEND_VALUES,
+  ADDONS_VALUES,
+  EXAMPLES_VALUES,
+  PACKAGE_MANAGER_VALUES,
+  DATABASE_SETUP_VALUES,
+  API_VALUES,
+  AUTH_VALUES,
+  PAYMENTS_VALUES,
+  WEB_DEPLOY_VALUES,
+  SERVER_DEPLOY_VALUES,
+  DIRECTORY_CONFLICT_VALUES,
+  TEMPLATE_VALUES,
+} from "@better-t-stack/types";
+
+export type {
+  Database,
+  ORM,
+  Backend,
+  Runtime,
+  Frontend,
+  Addons,
+  Examples,
+  PackageManager,
+  DatabaseSetup,
+  API,
+  Auth,
+  Payments,
+  WebDeploy,
+  ServerDeploy,
+  DirectoryConflict,
+  Template,
+  ProjectName,
+  CreateInput,
+  AddInput,
+  CLIInput,
+  ProjectConfig,
+  BetterTStackConfig,
+  InitResult,
+} from "@better-t-stack/types";

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 = process.env.CONVEX_INGEST_URL;
+
+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/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 { $ } from "bun";
+
+export async function commandExists(command: string) {
+  try {
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      const result = await $`where ${command}`.nothrow().quiet();
+      return result.exitCode === 0;
+    }
+
+    const result = await $`which ${command}`.nothrow().quiet();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}