create-better-t-stack 3.7.3-canary.8e4d5716 → 3.7.3-canary.fe324be3

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

@@ -1,98 +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,
-        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,33 +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,
-        deploy: "alchemy deploy",
-        destroy: "alchemy destroy",
-      };
-    }
-
-    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-  }
-}

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

@@ -1,98 +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,
-        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,253 +0,0 @@
-import { intro, log } from "@clack/prompts";
-import { createRouterClient, os } from "@orpc/server";
-import pc from "picocolors";
-import { createCli } from "trpc-cli";
-import z from "zod";
-import { addAddonsHandler, createProjectHandler } from "./helpers/core/command-handlers";
-import {
-  type AddInput,
-  type Addons,
-  AddonsSchema,
-  type API,
-  APISchema,
-  AuthSchema,
-  type Backend,
-  BackendSchema,
-  type BetterTStackConfig,
-  type CreateInput,
-  type Database,
-  DatabaseSchema,
-  type DatabaseSetup,
-  DatabaseSetupSchema,
-  type DirectoryConflict,
-  DirectoryConflictSchema,
-  type Examples,
-  ExamplesSchema,
-  type Frontend,
-  FrontendSchema,
-  type InitResult,
-  type ORM,
-  ORMSchema,
-  type PackageManager,
-  PackageManagerSchema,
-  PaymentsSchema,
-  type ProjectConfig,
-  ProjectNameSchema,
-  type Runtime,
-  RuntimeSchema,
-  type ServerDeploy,
-  ServerDeploySchema,
-  type Template,
-  TemplateSchema,
-  type WebDeploy,
-  WebDeploySchema,
-} from "./types";
-import { handleError } from "./utils/errors";
-import { getLatestCLIVersion } from "./utils/get-latest-cli-version";
-import { openUrl } from "./utils/open-url";
-import { renderTitle } from "./utils/render-title";
-import { displaySponsors, fetchSponsors } from "./utils/sponsors";
-
-export const router = os.router({
-  init: os
-    .meta({
-      description: "Create a new Better-T-Stack project",
-      default: true,
-      negateBooleans: true,
-    })
-    .input(
-      z.tuple([
-        ProjectNameSchema.optional(),
-        z.object({
-          template: TemplateSchema.optional().describe("Use a predefined template"),
-          yes: z.boolean().optional().default(false).describe("Use default configuration"),
-          yolo: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
-          verbose: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("Show detailed result information"),
-          database: DatabaseSchema.optional(),
-          orm: ORMSchema.optional(),
-          auth: AuthSchema.optional(),
-          payments: PaymentsSchema.optional(),
-          frontend: z.array(FrontendSchema).optional(),
-          addons: z.array(AddonsSchema).optional(),
-          examples: z.array(ExamplesSchema).optional(),
-          git: z.boolean().optional(),
-          packageManager: PackageManagerSchema.optional(),
-          install: z.boolean().optional(),
-          dbSetup: DatabaseSetupSchema.optional(),
-          backend: BackendSchema.optional(),
-          runtime: RuntimeSchema.optional(),
-          api: APISchema.optional(),
-          webDeploy: WebDeploySchema.optional(),
-          serverDeploy: ServerDeploySchema.optional(),
-          directoryConflict: DirectoryConflictSchema.optional(),
-          renderTitle: z.boolean().optional(),
-          disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
-          manualDb: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("Skip automatic/manual database setup prompt and use manual setup"),
-        }),
-      ]),
-    )
-    .handler(async ({ input }) => {
-      const [projectName, options] = input;
-      const combinedInput = {
-        projectName,
-        ...options,
-      };
-      const result = await createProjectHandler(combinedInput);
-
-      if (options.verbose) {
-        return result;
-      }
-    }),
-  add: os
-    .meta({
-      description: "Add addons or deployment configurations to an existing Better-T-Stack project",
-    })
-    .input(
-      z.tuple([
-        z.object({
-          addons: z.array(AddonsSchema).optional().default([]),
-          webDeploy: WebDeploySchema.optional(),
-          serverDeploy: ServerDeploySchema.optional(),
-          projectDir: z.string().optional(),
-          install: z
-            .boolean()
-            .optional()
-            .default(false)
-            .describe("Install dependencies after adding addons or deployment"),
-          packageManager: PackageManagerSchema.optional(),
-        }),
-      ]),
-    )
-    .handler(async ({ input }) => {
-      const [options] = input;
-      await addAddonsHandler(options);
-    }),
-  sponsors: os.meta({ description: "Show Better-T-Stack sponsors" }).handler(async () => {
-    try {
-      renderTitle();
-      intro(pc.magenta("Better-T-Stack Sponsors"));
-      const sponsors = await fetchSponsors();
-      displaySponsors(sponsors);
-    } catch (error) {
-      handleError(error, "Failed to display sponsors");
-    }
-  }),
-  docs: os.meta({ description: "Open Better-T-Stack documentation" }).handler(async () => {
-    const DOCS_URL = "https://better-t-stack.dev/docs";
-    try {
-      await openUrl(DOCS_URL);
-      log.success(pc.blue("Opened docs in your default browser."));
-    } catch {
-      log.message(`Please visit ${DOCS_URL}`);
-    }
-  }),
-  builder: os.meta({ description: "Open the web-based stack builder" }).handler(async () => {
-    const BUILDER_URL = "https://better-t-stack.dev/new";
-    try {
-      await openUrl(BUILDER_URL);
-      log.success(pc.blue("Opened builder in your default browser."));
-    } catch {
-      log.message(`Please visit ${BUILDER_URL}`);
-    }
-  }),
-});
-
-const caller = createRouterClient(router, { context: {} });
-
-export function createBtsCli() {
-  return createCli({
-    router,
-    name: "create-better-t-stack",
-    version: getLatestCLIVersion(),
-  });
-}
-
-/**
- * Initialize a new Better-T-Stack project
- *
- * @example CLI usage:
- * ```bash
- * npx create-better-t-stack my-app --yes
- * ```
- *
- * @example Programmatic usage (always returns structured data):
- * ```typescript
- * import { init } from "create-better-t-stack";
- *
- * const result = await init("my-app", {
- *   yes: true,
- *   frontend: ["tanstack-router"],
- *   backend: "hono",
- *   database: "sqlite",
- *   orm: "drizzle",
- *   auth: "better-auth",
- *   addons: ["biome", "turborepo"],
- *   packageManager: "bun",
- *   install: false,
- *   directoryConflict: "increment", // auto-handle conflicts
- *   disableAnalytics: true, // disable analytics
- * });
- *
- * if (result.success) {
- *   console.log(`Project created at: ${result.projectDirectory}`);
- *   console.log(`Reproducible command: ${result.reproducibleCommand}`);
- *   console.log(`Time taken: ${result.elapsedTimeMs}ms`);
- * }
- * ```
- */
-export async function init(projectName?: string, options?: CreateInput) {
-  const opts = (options ?? {}) as CreateInput;
-  const programmaticOpts = { ...opts, verbose: true };
-  const prev = process.env.BTS_PROGRAMMATIC;
-  process.env.BTS_PROGRAMMATIC = "1";
-  const result = await caller.init([projectName, programmaticOpts]);
-  if (prev === undefined) delete process.env.BTS_PROGRAMMATIC;
-  else process.env.BTS_PROGRAMMATIC = prev;
-  return result as InitResult;
-}
-
-export async function sponsors() {
-  return caller.sponsors();
-}
-
-export async function docs() {
-  return caller.docs();
-}
-
-export async function builder() {
-  return caller.builder();
-}
-
-export type {
-  Database,
-  ORM,
-  Backend,
-  Runtime,
-  Frontend,
-  Addons,
-  Examples,
-  PackageManager,
-  DatabaseSetup,
-  API,
-  WebDeploy,
-  ServerDeploy,
-  DirectoryConflict,
-  Template,
-  CreateInput,
-  AddInput,
-  ProjectConfig,
-  BetterTStackConfig,
-  InitResult,
-};