create-better-t-stack 3.11.0-pr750.6c25d46 → 3.11.1

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

@@ -1,99 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,51 +0,0 @@
-/**
- * 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

@@ -1,200 +0,0 @@
-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;
-}