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

package/src/helpers/deployment/alchemy/alchemy-svelte-setup.ts

@@ -0,0 +1,99 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { IndentationText, Node, Project, QuoteKind } from "ts-morph";
+import type { PackageManager } from "../../../types";
+import { addPackageDependency } from "../../../utils/add-package-deps";
+
+export async function setupSvelteAlchemyDeploy(
+  projectDir: string,
+  _packageManager: PackageManager,
+  options?: { skipAppScripts?: boolean },
+) {
+  const webAppDir = path.join(projectDir, "apps/web");
+  if (!(await fs.pathExists(webAppDir))) return;
+
+  await addPackageDependency({
+    devDependencies: ["alchemy", "@sveltejs/adapter-cloudflare"],
+    projectDir: webAppDir,
+  });
+
+  const pkgPath = path.join(webAppDir, "package.json");
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+
+    if (!options?.skipAppScripts) {
+      pkg.scripts = {
+        ...pkg.scripts,
+        dev: "alchemy dev",
+        deploy: "alchemy deploy",
+        destroy: "alchemy destroy",
+      };
+    }
+
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+
+  const svelteConfigPath = path.join(webAppDir, "svelte.config.js");
+  if (!(await fs.pathExists(svelteConfigPath))) return;
+
+  try {
+    const project = new Project({
+      manipulationSettings: {
+        indentationText: IndentationText.TwoSpaces,
+        quoteKind: QuoteKind.Single,
+      },
+    });
+
+    project.addSourceFileAtPath(svelteConfigPath);
+    const sourceFile = project.getSourceFileOrThrow(svelteConfigPath);
+
+    const importDeclarations = sourceFile.getImportDeclarations();
+    const adapterImport = importDeclarations.find((imp) =>
+      imp.getModuleSpecifierValue().includes("@sveltejs/adapter"),
+    );
+
+    if (adapterImport) {
+      adapterImport.setModuleSpecifier("alchemy/cloudflare/sveltekit");
+      adapterImport.removeDefaultImport();
+      adapterImport.setDefaultImport("alchemy");
+    } else {
+      sourceFile.insertImportDeclaration(0, {
+        moduleSpecifier: "alchemy/cloudflare/sveltekit",
+        defaultImport: "alchemy",
+      });
+    }
+
+    const configVariable = sourceFile.getVariableDeclaration("config");
+    if (configVariable) {
+      const initializer = configVariable.getInitializer();
+      if (Node.isObjectLiteralExpression(initializer)) {
+        updateAdapterInConfig(initializer);
+      }
+    }
+
+    await project.save();
+  } catch (error) {
+    console.warn("Failed to update svelte.config.js:", error);
+  }
+}
+
+function updateAdapterInConfig(configObject: Node) {
+  if (!Node.isObjectLiteralExpression(configObject)) return;
+
+  const kitProperty = configObject.getProperty("kit");
+  if (kitProperty && Node.isPropertyAssignment(kitProperty)) {
+    const kitInitializer = kitProperty.getInitializer();
+    if (Node.isObjectLiteralExpression(kitInitializer)) {
+      const adapterProperty = kitInitializer.getProperty("adapter");
+      if (adapterProperty && Node.isPropertyAssignment(adapterProperty)) {
+        const initializer = adapterProperty.getInitializer();
+        if (Node.isCallExpression(initializer)) {
+          const expression = initializer.getExpression();
+          if (Node.isIdentifier(expression) && expression.getText() === "adapter") {
+            expression.replaceWithText("alchemy");
+          }
+        }
+      }
+    }
+  }
+}

package/src/helpers/deployment/alchemy/alchemy-tanstack-router-setup.ts

@@ -0,0 +1,34 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { PackageManager } from "../../../types";
+import { addPackageDependency } from "../../../utils/add-package-deps";
+
+export async function setupTanStackRouterAlchemyDeploy(
+  projectDir: string,
+  _packageManager: PackageManager,
+  options?: { skipAppScripts?: boolean },
+) {
+  const webAppDir = path.join(projectDir, "apps/web");
+  if (!(await fs.pathExists(webAppDir))) return;
+
+  await addPackageDependency({
+    devDependencies: ["alchemy"],
+    projectDir: webAppDir,
+  });
+
+  const pkgPath = path.join(webAppDir, "package.json");
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+
+    if (!options?.skipAppScripts) {
+      pkg.scripts = {
+        ...pkg.scripts,
+        dev: "alchemy dev",
+        deploy: "alchemy deploy",
+        destroy: "alchemy destroy",
+      };
+    }
+
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+}

package/src/helpers/deployment/alchemy/alchemy-tanstack-start-setup.ts

@@ -0,0 +1,99 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { IndentationText, Node, Project, QuoteKind } from "ts-morph";
+import type { PackageManager } from "../../../types";
+import { addPackageDependency } from "../../../utils/add-package-deps";
+
+export async function setupTanStackStartAlchemyDeploy(
+  projectDir: string,
+  _packageManager: PackageManager,
+  options?: { skipAppScripts?: boolean },
+) {
+  const webAppDir = path.join(projectDir, "apps/web");
+  if (!(await fs.pathExists(webAppDir))) return;
+
+  await addPackageDependency({
+    devDependencies: ["alchemy", "@cloudflare/vite-plugin"],
+    projectDir: webAppDir,
+  });
+
+  const pkgPath = path.join(webAppDir, "package.json");
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+
+    if (!options?.skipAppScripts) {
+      pkg.scripts = {
+        ...pkg.scripts,
+        dev: "alchemy dev",
+        deploy: "alchemy deploy",
+        destroy: "alchemy destroy",
+      };
+    }
+
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+
+  const viteConfigPath = path.join(webAppDir, "vite.config.ts");
+  if (await fs.pathExists(viteConfigPath)) {
+    try {
+      const project = new Project({
+        manipulationSettings: {
+          indentationText: IndentationText.TwoSpaces,
+          quoteKind: QuoteKind.Double,
+        },
+      });
+
+      project.addSourceFileAtPath(viteConfigPath);
+      const sourceFile = project.getSourceFileOrThrow(viteConfigPath);
+
+      const alchemyImport = sourceFile.getImportDeclaration("alchemy/cloudflare/tanstack-start");
+      if (!alchemyImport) {
+        sourceFile.addImportDeclaration({
+          moduleSpecifier: "alchemy/cloudflare/tanstack-start",
+          defaultImport: "alchemy",
+        });
+      } else {
+        alchemyImport.setModuleSpecifier("alchemy/cloudflare/tanstack-start");
+      }
+
+      const exportAssignment = sourceFile.getExportAssignment((d) => !d.isExportEquals());
+      if (!exportAssignment) return;
+
+      const defineConfigCall = exportAssignment.getExpression();
+      if (
+        !Node.isCallExpression(defineConfigCall) ||
+        defineConfigCall.getExpression().getText() !== "defineConfig"
+      )
+        return;
+
+      let configObject = defineConfigCall.getArguments()[0];
+      if (!configObject) {
+        configObject = defineConfigCall.addArgument("{}");
+      }
+
+      if (Node.isObjectLiteralExpression(configObject)) {
+        const pluginsProperty = configObject.getProperty("plugins");
+        if (pluginsProperty && Node.isPropertyAssignment(pluginsProperty)) {
+          const initializer = pluginsProperty.getInitializer();
+          if (Node.isArrayLiteralExpression(initializer)) {
+            const hasAlchemy = initializer
+              .getElements()
+              .some((el) => el.getText().includes("alchemy("));
+            if (!hasAlchemy) {
+              initializer.addElement("alchemy()");
+            }
+          }
+        } else {
+          configObject.addPropertyAssignment({
+            name: "plugins",
+            initializer: "[alchemy()]",
+          });
+        }
+      }
+
+      await project.save();
+    } catch (error) {
+      console.warn("Failed to update vite.config.ts:", error);
+    }
+  }
+}

package/src/helpers/deployment/alchemy/env-dts-setup.ts

@@ -0,0 +1,76 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { Project } from "ts-morph";
+import type { ProjectConfig } from "../../../types";
+
+const tsProject = new Project({
+  useInMemoryFileSystem: false,
+  skipAddingFilesFromTsConfig: true,
+});
+
+function determineImportPath(
+  envDtsPath: string,
+  projectDir: string,
+  config: ProjectConfig,
+): string {
+  const { webDeploy, serverDeploy, backend } = config;
+  const isBackendSelf = backend === "self";
+
+  let alchemyRunPath: string;
+
+  if (webDeploy === "alchemy" && (serverDeploy === "alchemy" || isBackendSelf)) {
+    // Both web and server are alchemy, or web + backend=self
+    if (isBackendSelf) {
+      alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
+    } else {
+      alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
+    }
+  } else if (webDeploy === "alchemy") {
+    // Only web is alchemy
+    alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
+  } else if (serverDeploy === "alchemy") {
+    // Only server is alchemy
+    alchemyRunPath = path.join(projectDir, "apps/server/alchemy.run.ts");
+  } else {
+    // Should not happen, but fallback
+    alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
+  }
+
+  // Calculate relative path from env.d.ts to alchemy.run.ts
+  const relativePath = path.relative(path.dirname(envDtsPath), alchemyRunPath.replace(/\.ts$/, ""));
+
+  // Normalize the path for imports (use forward slashes, handle relative paths)
+  const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+
+  return importPath.replace(/\\/g, "/");
+}
+
+export async function setupEnvDtsImport(
+  envDtsPath: string,
+  projectDir: string,
+  config: ProjectConfig,
+) {
+  if (!(await fs.pathExists(envDtsPath))) {
+    return;
+  }
+
+  const importPath = determineImportPath(envDtsPath, projectDir, config);
+
+  const sourceFile = tsProject.addSourceFileAtPath(envDtsPath);
+
+  const existingImports = sourceFile.getImportDeclarations();
+  const alreadyHasImport = existingImports.some(
+    (imp) =>
+      imp.getModuleSpecifierValue() === importPath &&
+      imp.getNamedImports().some((named) => named.getName() === "server"),
+  );
+
+  if (!alreadyHasImport) {
+    sourceFile.insertImportDeclaration(0, {
+      moduleSpecifier: importPath,
+      namedImports: [{ name: "server", isTypeOnly: true }],
+    });
+  }
+
+  await sourceFile.save();
+}

package/src/helpers/deployment/alchemy/index.ts

@@ -0,0 +1,7 @@
+export { setupNextAlchemyDeploy } from "./alchemy-next-setup";
+export { setupNuxtAlchemyDeploy } from "./alchemy-nuxt-setup";
+export { setupReactRouterAlchemyDeploy } from "./alchemy-react-router-setup";
+export { setupSolidAlchemyDeploy } from "./alchemy-solid-setup";
+export { setupSvelteAlchemyDeploy } from "./alchemy-svelte-setup";
+export { setupTanStackRouterAlchemyDeploy } from "./alchemy-tanstack-router-setup";
+export { setupTanStackStartAlchemyDeploy } from "./alchemy-tanstack-start-setup";

package/src/helpers/deployment/server-deploy-setup.ts

@@ -0,0 +1,55 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+
+export async function setupServerDeploy(config: ProjectConfig) {
+  const { serverDeploy, webDeploy, projectDir } = config;
+
+  if (serverDeploy === "none") return;
+
+  if (serverDeploy === "alchemy" && webDeploy === "alchemy") {
+    return;
+  }
+
+  const serverDir = path.join(projectDir, "apps/server");
+  if (!(await fs.pathExists(serverDir))) return;
+
+  if (serverDeploy === "alchemy") {
+    await setupAlchemyServerDeploy(serverDir, projectDir);
+  }
+}
+
+export async function setupAlchemyServerDeploy(serverDir: string, projectDir?: string) {
+  if (!(await fs.pathExists(serverDir))) return;
+
+  await addPackageDependency({
+    devDependencies: ["alchemy", "wrangler", "@types/node", "@cloudflare/workers-types"],
+    projectDir: serverDir,
+  });
+
+  if (projectDir) {
+    await addAlchemyPackagesDependencies(projectDir);
+  }
+
+  const packageJsonPath = path.join(serverDir, "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await fs.readJson(packageJsonPath);
+
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      dev: "alchemy dev",
+      deploy: "alchemy deploy",
+      destroy: "alchemy destroy",
+    };
+
+    await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  }
+}
+
+async function addAlchemyPackagesDependencies(projectDir: string) {
+  await addPackageDependency({
+    devDependencies: ["@cloudflare/workers-types"],
+    projectDir,
+  });
+}

package/src/helpers/deployment/web-deploy-setup.ts

@@ -0,0 +1,58 @@
+import type { ProjectConfig } from "../../types";
+import { addPackageDependency } from "../../utils/add-package-deps";
+import { setupCombinedAlchemyDeploy } from "./alchemy/alchemy-combined-setup";
+import { setupNextAlchemyDeploy } from "./alchemy/alchemy-next-setup";
+import { setupNuxtAlchemyDeploy } from "./alchemy/alchemy-nuxt-setup";
+import { setupReactRouterAlchemyDeploy } from "./alchemy/alchemy-react-router-setup";
+import { setupSolidAlchemyDeploy } from "./alchemy/alchemy-solid-setup";
+import { setupSvelteAlchemyDeploy } from "./alchemy/alchemy-svelte-setup";
+import { setupTanStackRouterAlchemyDeploy } from "./alchemy/alchemy-tanstack-router-setup";
+import { setupTanStackStartAlchemyDeploy } from "./alchemy/alchemy-tanstack-start-setup";
+
+export async function setupWebDeploy(config: ProjectConfig) {
+  const { webDeploy, serverDeploy, frontend, projectDir } = config;
+  const { packageManager } = config;
+
+  if (webDeploy === "none") return;
+
+  if (webDeploy !== "alchemy") return;
+
+  if (webDeploy === "alchemy" && serverDeploy === "alchemy") {
+    await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
+    await addAlchemyPackagesDependencies(projectDir);
+    return;
+  }
+
+  const isNext = frontend.includes("next");
+  const isNuxt = frontend.includes("nuxt");
+  const isSvelte = frontend.includes("svelte");
+  const isTanstackRouter = frontend.includes("tanstack-router");
+  const isTanstackStart = frontend.includes("tanstack-start");
+  const isReactRouter = frontend.includes("react-router");
+  const isSolid = frontend.includes("solid");
+
+  if (isNext) {
+    await setupNextAlchemyDeploy(projectDir, packageManager);
+  } else if (isNuxt) {
+    await setupNuxtAlchemyDeploy(projectDir, packageManager);
+  } else if (isSvelte) {
+    await setupSvelteAlchemyDeploy(projectDir, packageManager);
+  } else if (isTanstackStart) {
+    await setupTanStackStartAlchemyDeploy(projectDir, packageManager);
+  } else if (isTanstackRouter) {
+    await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
+  } else if (isReactRouter) {
+    await setupReactRouterAlchemyDeploy(projectDir, packageManager);
+  } else if (isSolid) {
+    await setupSolidAlchemyDeploy(projectDir, packageManager);
+  }
+
+  await addAlchemyPackagesDependencies(projectDir);
+}
+
+async function addAlchemyPackagesDependencies(projectDir: string) {
+  await addPackageDependency({
+    devDependencies: ["@cloudflare/workers-types"],
+    projectDir,
+  });
+}

package/src/index.ts

@@ -0,0 +1,51 @@
+/**
+ * create-better-t-stack
+ *
+ * A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects.
+ *
+ * @example Programmatic usage
+ * ```typescript
+ * import { create } from "create-better-t-stack";
+ *
+ * const result = await create({
+ *   projectName: "my-app",
+ *   frontend: ["tanstack-router"],
+ *   backend: "hono",
+ *   database: "sqlite",
+ *   orm: "drizzle",
+ *   defaults: true,
+ * });
+ *
+ * if (result.success) {
+ *   console.log(`Created at: ${result.projectDirectory}`);
+ * }
+ * ```
+ */
+
+// Main programmatic API
+export { create, type CreateOptions, type CreateResult } from "./api";
+
+// Re-export types for type-safe usage
+export type {
+  Addons,
+  API,
+  Auth,
+  Backend,
+  Database,
+  DatabaseSetup,
+  Examples,
+  Frontend,
+  ORM,
+  PackageManager,
+  Payments,
+  ProjectConfig,
+  Runtime,
+  ServerDeploy,
+  WebDeploy,
+  DirectoryConflict,
+  Template,
+  BetterTStackConfig,
+} from "./types";
+
+// Legacy exports for backwards compatibility (deprecated)
+export { create as init } from "./api";

package/src/prompts/addons.ts

@@ -0,0 +1,200 @@
+import { groupMultiselect, isCancel } from "@clack/prompts";
+import { DEFAULT_CONFIG } from "../constants";
+import { type Addons, AddonsSchema, type Auth, type Frontend } from "../types";
+import { getCompatibleAddons, validateAddonCompatibility } from "../utils/compatibility-rules";
+import { exitCancelled } from "../utils/errors";
+
+type AddonOption = {
+  value: Addons;
+  label: string;
+  hint: string;
+};
+
+function getAddonDisplay(addon: Addons): { label: string; hint: string } {
+  let label: string;
+  let hint: string;
+
+  switch (addon) {
+    case "turborepo":
+      label = "Turborepo";
+      hint = "High-performance build system";
+      break;
+    case "pwa":
+      label = "PWA";
+      hint = "Make your app installable and work offline";
+      break;
+    case "tauri":
+      label = "Tauri";
+      hint = "Build native desktop apps from your web frontend";
+      break;
+    case "biome":
+      label = "Biome";
+      hint = "Format, lint, and more";
+      break;
+    case "oxlint":
+      label = "Oxlint";
+      hint = "Oxlint + Oxfmt (linting & formatting)";
+      break;
+    case "ultracite":
+      label = "Ultracite";
+      hint = "Zero-config Biome preset with AI integration";
+      break;
+    case "ruler":
+      label = "Ruler";
+      hint = "Centralize your AI rules";
+      break;
+    case "husky":
+      label = "Husky";
+      hint = "Modern native Git hooks made easy";
+      break;
+    case "starlight":
+      label = "Starlight";
+      hint = "Build stellar docs with astro";
+      break;
+    case "fumadocs":
+      label = "Fumadocs";
+      hint = "Build excellent documentation site";
+      break;
+    case "opentui":
+      label = "OpenTUI";
+      hint = "Build terminal user interfaces";
+      break;
+    case "wxt":
+      label = "WXT";
+      hint = "Build browser extensions";
+      break;
+    default:
+      label = addon;
+      hint = `Add ${addon}`;
+  }
+
+  return { label, hint };
+}
+
+const ADDON_GROUPS = {
+  Documentation: ["starlight", "fumadocs"],
+  Linting: ["biome", "oxlint", "ultracite"],
+  Other: ["ruler", "pwa", "tauri", "husky", "opentui", "wxt", "turborepo"],
+};
+
+export async function getAddonsChoice(addons?: Addons[], frontends?: Frontend[], auth?: Auth) {
+  if (addons !== undefined) return addons;
+
+  const allAddons = AddonsSchema.options.filter((addon) => addon !== "none");
+  const groupedOptions: Record<string, AddonOption[]> = {
+    Documentation: [],
+    Linting: [],
+    Other: [],
+  };
+
+  const frontendsArray = frontends || [];
+
+  for (const addon of allAddons) {
+    const { isCompatible } = validateAddonCompatibility(addon, frontendsArray, auth);
+    if (!isCompatible) continue;
+
+    const { label, hint } = getAddonDisplay(addon);
+    const option = { value: addon, label, hint };
+
+    if (ADDON_GROUPS.Documentation.includes(addon)) {
+      groupedOptions.Documentation.push(option);
+    } else if (ADDON_GROUPS.Linting.includes(addon)) {
+      groupedOptions.Linting.push(option);
+    } else if (ADDON_GROUPS.Other.includes(addon)) {
+      groupedOptions.Other.push(option);
+    }
+  }
+
+  Object.keys(groupedOptions).forEach((group) => {
+    if (groupedOptions[group].length === 0) {
+      delete groupedOptions[group];
+    } else {
+      const groupOrder = ADDON_GROUPS[group as keyof typeof ADDON_GROUPS] || [];
+      groupedOptions[group].sort((a, b) => {
+        const indexA = groupOrder.indexOf(a.value);
+        const indexB = groupOrder.indexOf(b.value);
+        return indexA - indexB;
+      });
+    }
+  });
+
+  const initialValues = DEFAULT_CONFIG.addons.filter((addonValue) =>
+    Object.values(groupedOptions).some((options) =>
+      options.some((opt) => opt.value === addonValue),
+    ),
+  );
+
+  const response = await groupMultiselect<Addons>({
+    message: "Select addons",
+    options: groupedOptions,
+    initialValues: initialValues,
+    required: false,
+    selectableGroups: false,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}
+
+export async function getAddonsToAdd(
+  frontend: Frontend[],
+  existingAddons: Addons[] = [],
+  auth?: Auth,
+) {
+  const groupedOptions: Record<string, AddonOption[]> = {
+    Documentation: [],
+    Linting: [],
+    Other: [],
+  };
+
+  const frontendArray = frontend || [];
+
+  const compatibleAddons = getCompatibleAddons(
+    AddonsSchema.options.filter((addon) => addon !== "none"),
+    frontendArray,
+    existingAddons,
+    auth,
+  );
+
+  for (const addon of compatibleAddons) {
+    const { label, hint } = getAddonDisplay(addon);
+    const option = { value: addon, label, hint };
+
+    if (ADDON_GROUPS.Documentation.includes(addon)) {
+      groupedOptions.Documentation.push(option);
+    } else if (ADDON_GROUPS.Linting.includes(addon)) {
+      groupedOptions.Linting.push(option);
+    } else if (ADDON_GROUPS.Other.includes(addon)) {
+      groupedOptions.Other.push(option);
+    }
+  }
+
+  Object.keys(groupedOptions).forEach((group) => {
+    if (groupedOptions[group].length === 0) {
+      delete groupedOptions[group];
+    } else {
+      const groupOrder = ADDON_GROUPS[group as keyof typeof ADDON_GROUPS] || [];
+      groupedOptions[group].sort((a, b) => {
+        const indexA = groupOrder.indexOf(a.value);
+        const indexB = groupOrder.indexOf(b.value);
+        return indexA - indexB;
+      });
+    }
+  });
+
+  if (Object.keys(groupedOptions).length === 0) {
+    return [];
+  }
+
+  const response = await groupMultiselect<Addons>({
+    message: "Select addons to add",
+    options: groupedOptions,
+    required: false,
+    selectableGroups: false,
+  });
+
+  if (isCancel(response)) return exitCancelled("Operation cancelled");
+
+  return response;
+}