create-better-fullstack 2.1.0 → 2.1.2

package/dist/{add-handler-BjTmOwEN.mjs → add-handler-9F-AsGM-.mjs}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { a as updateBtsConfig, r as readBtsConfig, u as getDefaultConfig } from "./bts-config-InNcw1aJ.mjs";
+import { c as isSilent, g as updateBtsConfig, l as runWithContextAsync, m as readBtsConfig, n as UserCancelledError, t as CLIError, x as getDefaultConfig } from "./errors-D9yiiGVq.mjs";
 import { t as renderTitle } from "./render-title-zvyKC1ej.mjs";
-import { c as isSilent, l as runWithContextAsync, n as UserCancelledError, t as CLIError } from "./errors-ns_o2OKg.mjs";
-import { t as setupAddons } from "./addons-setup-uSvqHagW.mjs";
-import { c as applyDependencyVersionChannel, t as installDependencies, u as getAddonsToAdd } from "./install-dependencies-CDjTNvIV.mjs";
+import { t as setupAddons } from "./addons-setup-C_xrNtkL.mjs";
+import "./compatibility-rules-D7zYNVjC.mjs";
+import { c as applyDependencyVersionChannel, t as installDependencies, u as getAddonsToAdd } from "./install-dependencies-DDGF-zDG.mjs";
 import { intro, log, outro } from "@clack/prompts";
 import pc from "picocolors";
 import fs from "fs-extra";

package/dist/addons-setup-C8eaCaH5.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./errors-D9yiiGVq.mjs";
+import { t as setupAddons } from "./addons-setup-C_xrNtkL.mjs";
+
+export { setupAddons };

package/dist/{addons-setup-uSvqHagW.mjs → addons-setup-C_xrNtkL.mjs}

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
-import { r as readBtsConfig } from "./bts-config-InNcw1aJ.mjs";
-import { c as isSilent, r as exitCancelled } from "./errors-ns_o2OKg.mjs";
+import { c as isSilent, m as readBtsConfig, r as exitCancelled } from "./errors-D9yiiGVq.mjs";
 import { autocompleteMultiselect, group, isCancel, log, multiselect, select, spinner } from "@clack/prompts";
 import pc from "picocolors";
 import fs from "fs-extra";

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 //#region src/cli.ts
-if (process.argv[2] === "mcp" && process.argv.length === 3) import("./mcp-BaLHDRdC.mjs").then((m) => m.startMcpServer());
-else import("./run-DYWSKowD.mjs").then((m) => m.createBtsCli().run());
+if (process.argv[2] === "mcp" && process.argv.length === 3) import("./mcp-BXLhb7wW.mjs").then((m) => m.startMcpServer());
+else import("./run-BmRKR2wG.mjs").then((m) => m.createBtsCli().run());
 
 //#endregion
 export {  };

package/dist/compatibility-rules-D7zYNVjC.mjs

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+import { c as isSilent, i as exitWithError, t as CLIError } from "./errors-D9yiiGVq.mjs";
+import pc from "picocolors";
+import { allowedApisForFrontends, getAIFrontendCompatibilityIssue, getApiFrontendCompatibilityIssue, getCompatibleAddons, getCompatibleCSSFrameworks, getCompatibleUILibraries, getUnsupportedWebDeployFrontend, hasDockerComposeCompatibleFrontend, hasWebStyling, isBackendUtilsCompatibleBackend, isExampleAIAllowed, isExampleChatSdkAllowed, isFrontendAllowedWithBackend, isWebFrontend, requiresChatSdkVercelAIForSelection, splitFrontends, validateAddonCompatibility } from "@better-fullstack/types";
+import consola from "consola";
+
+//#region src/utils/error-formatter.ts
+function getCategoryTitle(category) {
+	return {
+		incompatibility: "Incompatible Options",
+		"invalid-selection": "Invalid Selection",
+		"missing-requirement": "Missing Requirement",
+		constraint: "Constraint Violation"
+	}[category];
+}
+function displayStructuredError(error) {
+	if (isSilent()) throw new CLIError(error.message);
+	const lines = [];
+	lines.push(pc.bold(pc.red(getCategoryTitle(error.category))));
+	lines.push("");
+	lines.push(error.message);
+	if (error.provided && Object.keys(error.provided).length > 0) {
+		lines.push("");
+		lines.push(pc.dim("You provided:"));
+		for (const [key, value] of Object.entries(error.provided)) {
+			const displayValue = Array.isArray(value) ? value.join(", ") : value;
+			lines.push(`  ${pc.cyan("--" + key)} ${displayValue}`);
+		}
+	}
+	if (error.suggestions.length > 0) {
+		lines.push("");
+		lines.push(pc.dim("Suggestions:"));
+		for (const suggestion of error.suggestions) lines.push(`  ${pc.green("•")} ${suggestion}`);
+	}
+	consola.box({
+		title: pc.red("Error"),
+		message: lines.join("\n"),
+		style: { borderColor: "red" }
+	});
+	process.exit(1);
+}
+function incompatibilityError(opts) {
+	return displayStructuredError({
+		category: "incompatibility",
+		...opts
+	});
+}
+function invalidSelectionError(opts) {
+	return displayStructuredError({
+		category: "invalid-selection",
+		...opts
+	});
+}
+function missingRequirementError(opts) {
+	return displayStructuredError({
+		category: "missing-requirement",
+		...opts
+	});
+}
+function constraintError(opts) {
+	return displayStructuredError({
+		category: "constraint",
+		...opts
+	});
+}
+
+//#endregion
+//#region src/utils/compatibility-rules.ts
+function isWebFrontend$1(value) {
+	return isWebFrontend(value);
+}
+function splitFrontends$1(values = []) {
+	return splitFrontends(values);
+}
+function ensureSingleWebAndNative(frontends) {
+	const { web, native } = splitFrontends$1(frontends);
+	if (web.length > 1) invalidSelectionError({
+		message: "Only one web framework can be selected per project.",
+		provided: { frontend: web },
+		suggestions: ["Keep one web framework and remove the others", "Use separate projects for multiple web frameworks"]
+	});
+	if (native.length > 1) invalidSelectionError({
+		message: "Only one native framework can be selected per project.",
+		provided: { frontend: native },
+		suggestions: ["Keep one native framework and remove the others", "Choose: native-bare, native-uniwind, or native-unistyles"]
+	});
+}
+const FULLSTACK_FRONTENDS = [
+	"next",
+	"vinext",
+	"tanstack-start",
+	"astro",
+	"nuxt",
+	"svelte",
+	"solid-start"
+];
+function validateSelfBackendCompatibility(providedFlags, options, config) {
+	const backend = config.backend || options.backend;
+	const frontends = config.frontend || options.frontend || [];
+	if (backend === "self") {
+		const { web, native } = splitFrontends$1(frontends);
+		if (!(web.length === 1 && FULLSTACK_FRONTENDS.includes(web[0]))) exitWithError("Backend 'self' (fullstack) only supports Next.js, Vinext, TanStack Start, Astro, Nuxt, SvelteKit, or SolidStart frontends. Please use --frontend next, --frontend vinext, --frontend tanstack-start, --frontend astro, --frontend nuxt, --frontend svelte, or --frontend solid-start.");
+		if (native.length > 1) exitWithError("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
+	}
+	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS.includes(f));
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") exitWithError("Backend 'self' (fullstack) only supports Next.js, Vinext, TanStack Start, Astro, Nuxt, SvelteKit, or SolidStart frontends. Please use --frontend next, --frontend vinext, --frontend tanstack-start, --frontend astro, --frontend nuxt, --frontend svelte, --frontend solid-start, or choose a different backend.");
+}
+const WORKERS_COMPATIBLE_BACKENDS = [
+	"hono",
+	"nitro",
+	"fets"
+];
+function validateWorkersCompatibility(providedFlags, options, config) {
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && !WORKERS_COMPATIBLE_BACKENDS.includes(config.backend)) incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently supported only with compatible backends (Hono, Nitro, or Fets).",
+		provided: {
+			runtime: "workers",
+			backend: config.backend
+		},
+		suggestions: [
+			"Use --backend hono",
+			"Use --backend nitro",
+			"Use --backend fets",
+			"Choose a different runtime (node, bun)"
+		]
+	});
+	if (providedFlags.has("backend") && config.backend && !WORKERS_COMPATIBLE_BACKENDS.includes(config.backend) && config.runtime === "workers") incompatibilityError({
+		message: `In Better-Fullstack, backend '${config.backend}' is currently not available with Cloudflare Workers runtime.`,
+		provided: {
+			backend: config.backend,
+			runtime: "workers"
+		},
+		suggestions: ["Use --backend hono, --backend nitro, or --backend fets", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.database === "mongodb") incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently not available with MongoDB.",
+		provided: {
+			runtime: "workers",
+			database: "mongodb"
+		},
+		suggestions: ["Use a different database (postgres, sqlite, mysql)", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.dbSetup === "docker") incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently not available with Docker database setup.",
+		provided: {
+			runtime: "workers",
+			"db-setup": "docker"
+		},
+		suggestions: ["Use --db-setup d1 for SQLite", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("database") && config.database === "mongodb" && config.runtime === "workers") incompatibilityError({
+		message: "In Better-Fullstack, MongoDB is currently not available with Cloudflare Workers runtime.",
+		provided: {
+			database: "mongodb",
+			runtime: "workers"
+		},
+		suggestions: ["Use a different database (postgres, sqlite, mysql)", "Choose a different runtime (node, bun)"]
+	});
+}
+function validateApiFrontendCompatibility(api, frontends = [], astroIntegration) {
+	const issue = getApiFrontendCompatibilityIssue(api, frontends, astroIntegration);
+	if (!issue) return;
+	incompatibilityError({
+		message: issue.message,
+		provided: issue.provided ?? {},
+		suggestions: issue.suggestions ?? []
+	});
+}
+function isFrontendAllowedWithBackend$1(frontend, backend, auth) {
+	return isFrontendAllowedWithBackend(frontend, backend, auth);
+}
+function allowedApisForFrontends$1(frontends = [], astroIntegration) {
+	return allowedApisForFrontends(frontends, astroIntegration);
+}
+function isExampleAIAllowed$1(backend, frontends = []) {
+	return isExampleAIAllowed(backend, frontends);
+}
+function isExampleChatSdkAllowed$1(backend, frontends = [], runtime) {
+	return isExampleChatSdkAllowed(backend, frontends, runtime);
+}
+function requiresChatSdkVercelAI(backend, frontends = [], runtime) {
+	return requiresChatSdkVercelAIForSelection(backend, frontends, runtime);
+}
+function validateWebDeployRequiresWebFrontend(webDeploy, hasWebFrontendFlag) {
+	if (webDeploy && webDeploy !== "none" && !hasWebFrontendFlag) exitWithError("'--web-deploy' requires a web frontend. Please select a web frontend or set '--web-deploy none'.");
+}
+function validateWebDeployFrontendTemplates(webDeploy, frontends = []) {
+	const blocked = getUnsupportedWebDeployFrontend(webDeploy, frontends);
+	if (blocked) exitWithError(`${webDeploy === "render" ? "Render" : "Netlify"} deployment is not yet wired up for the '${blocked}' frontend. Choose a different web deploy target or frontend.`);
+}
+function validateServerDeployRequiresBackend(serverDeploy, backend, hasGraphBackend = false) {
+	if (serverDeploy && serverDeploy !== "none" && !hasGraphBackend && (!backend || backend === "none")) exitWithError("'--server-deploy' requires a backend. Please select a backend or set '--server-deploy none'.");
+}
+function validateAddonCompatibility$1(addon, frontend, _auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database) {
+	const baseCompatibility = validateAddonCompatibility(addon, frontend, _auth);
+	if (!baseCompatibility.isCompatible) return baseCompatibility;
+	if (addon === "backend-utils") {
+		if (ecosystem !== void 0 && ecosystem !== "typescript") return {
+			isCompatible: false,
+			reason: "Backend Utils requires a TypeScript server stack"
+		};
+		if (backend !== void 0 && !isBackendUtilsCompatibleBackend(backend)) return {
+			isCompatible: false,
+			reason: "Backend Utils requires a Hono, Express, Fastify, Elysia, feTS, or NestJS backend"
+		};
+	}
+	if (addon === "docker-compose" || addon === "devcontainer") {
+		const label = addon === "devcontainer" ? "DevContainer" : "docker-compose";
+		const title = addon === "devcontainer" ? "DevContainer" : "Docker Compose";
+		if (backend === "convex") return {
+			isCompatible: false,
+			reason: `${label} is not compatible with Convex backend (managed service)`
+		};
+		if (runtime === "workers") return {
+			isCompatible: false,
+			reason: `${label} is not compatible with Cloudflare Workers runtime`
+		};
+		if (ecosystem !== void 0 && ![
+			"typescript",
+			"python",
+			"go",
+			"rust",
+			"java"
+		].includes(ecosystem)) return {
+			isCompatible: false,
+			reason: `${title} currently supports TypeScript, Python, Go, Rust, or Java projects`
+		};
+		if (ecosystem === "typescript" && !hasDockerComposeCompatibleFrontend(frontend)) return {
+			isCompatible: false,
+			reason: `${title} currently supports Next.js, Vinext, TanStack Router, React Router, React Vite, Solid, or Astro`
+		};
+		if (ecosystem === "typescript" && backend === "self" && !frontend.includes("next") && !frontend.includes("vinext")) return {
+			isCompatible: false,
+			reason: `${title} self-backend support currently requires Next.js or Vinext`
+		};
+		if (ecosystem === "rust" && rustFrontend && rustFrontend !== "none") return {
+			isCompatible: false,
+			reason: `${title} for Rust currently supports server-only projects`
+		};
+		if (ecosystem === "java" && javaWebFramework && javaWebFramework !== "spring-boot") return {
+			isCompatible: false,
+			reason: `${title} for Java currently requires Spring Boot`
+		};
+		if (ecosystem === "python" && database && database !== "none" && database !== "sqlite" && database !== "postgres") return {
+			isCompatible: false,
+			reason: `${title} for Python ORM projects currently supports SQLite defaults or Postgres`
+		};
+	}
+	return { isCompatible: true };
+}
+function getCompatibleAddons$1(allAddons, frontend, existingAddons = [], auth, backend, runtime) {
+	return getCompatibleAddons(allAddons, frontend, existingAddons, auth).filter((addon) => {
+		const { isCompatible } = validateAddonCompatibility$1(addon, frontend, auth, backend, runtime);
+		return isCompatible;
+	});
+}
+function validateAddonsAgainstFrontends(addons = [], frontends = [], auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database) {
+	if (addons.includes("nx") && addons.includes("turborepo")) exitWithError("Nx and Turborepo are alternative workspace runners. Choose one addon.");
+	for (const addon of addons) {
+		if (addon === "none") continue;
+		const { isCompatible, reason } = validateAddonCompatibility$1(addon, frontends, auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database);
+		if (!isCompatible) exitWithError(`Incompatible addon/frontend combination: ${reason}`);
+	}
+}
+function validatePaymentsCompatibility(payments, auth, _backend, frontends = []) {
+	if (!payments || payments === "none") return;
+	if (payments === "dodo" && frontends.includes("react-vite")) exitWithError("Dodo Payments are not yet supported for React + Vite projects.");
+	if (payments === "polar") {
+		if (!auth || auth === "none" || auth !== "better-auth" && auth !== "better-auth-organizations") exitWithError("Polar payments requires Better Auth. Please use '--auth better-auth' or choose a different payments provider.");
+		const { web } = splitFrontends$1(frontends);
+		if (web.length === 0 && frontends.length > 0) exitWithError("Polar payments requires a web frontend or no frontend. Please select a web frontend or choose a different payments provider.");
+	}
+}
+function validateExamplesCompatibility(examples, backend, frontend, runtime, ai) {
+	const examplesArr = examples ?? [];
+	if (examplesArr.length === 0 || examplesArr.includes("none")) return;
+	if (examplesArr.includes("tanstack-showcase")) {
+		const showcaseFrontends = ["tanstack-router", "tanstack-start"];
+		if (!(frontend ?? []).some((f) => showcaseFrontends.includes(f))) exitWithError("The 'tanstack-showcase' example requires TanStack Router or TanStack Start frontend.");
+	}
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) exitWithError("The 'ai' example is not compatible with the Solid frontend.");
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid-start")) exitWithError("The 'ai' example is not compatible with the SolidStart frontend.");
+	if (examplesArr.includes("ai") && backend === "convex") {
+		const frontendArr = frontend ?? [];
+		const includesNuxt = frontendArr.includes("nuxt");
+		const includesSvelte = frontendArr.includes("svelte");
+		if (includesNuxt || includesSvelte) exitWithError("The 'ai' example with Convex backend only supports React-based frontends (Next.js, TanStack Router, TanStack Start, React Router, React + Vite). Svelte and Nuxt are not supported with Convex AI.");
+	}
+	if (examplesArr.includes("chat-sdk")) {
+		const frontendArr = frontend ?? [];
+		if (frontendArr.includes("react-vite")) exitWithError("The 'chat-sdk' example is not yet supported for React + Vite projects.");
+		if (!isExampleChatSdkAllowed$1(backend, frontendArr, runtime)) {
+			if (backend === "none") exitWithError("The 'chat-sdk' example requires a backend.");
+			if (backend === "convex") exitWithError("The 'chat-sdk' example is not supported with the Convex backend in v1. Use self backend (Next.js, TanStack Start, Nuxt) or Hono with Node runtime.");
+			if (backend === "self") exitWithError("The 'chat-sdk' example with self backend only supports Next.js, TanStack Start, or Nuxt frontends in v1.");
+			if (backend === "hono" && runtime !== "node") exitWithError("The 'chat-sdk' example with Hono requires '--runtime node' in v1 (Bun/Workers not supported yet).");
+			exitWithError("The 'chat-sdk' example is only supported with self backend (Next.js, TanStack Start, Nuxt) or Hono with Node runtime in v1.");
+		}
+		if (requiresChatSdkVercelAI(backend, frontendArr, runtime) && ai && ai !== "vercel-ai") exitWithError("The 'chat-sdk' example requires '--ai vercel-ai' for the selected stack in v1 (Nuxt Discord and Hono GitHub profiles).");
+	}
+}
+/**
+* Validates that TanStack AI is only used with compatible frontends (React or Solid).
+* Server-side @tanstack/ai core works anywhere, but client adapters only exist for React and Solid.
+*/
+function validateAIFrontendCompatibility(ai, frontends = []) {
+	const issue = getAIFrontendCompatibilityIssue(ai, frontends);
+	if (!issue) return;
+	exitWithError(issue.message);
+}
+/**
+* Validates that a UI library is compatible with the selected frontend(s)
+*/
+function validateUILibraryFrontendCompatibility(uiLibrary, frontends = [], astroIntegration) {
+	if (!uiLibrary || uiLibrary === "none") return;
+	const { web } = splitFrontends$1(frontends);
+	if (web.length === 0) return;
+	const compatible = getCompatibleUILibraries(frontends, astroIntegration);
+	if (!compatible.includes(uiLibrary)) {
+		const isAstroNonReact = web.includes("astro") && astroIntegration !== "react";
+		const supportsAstroReact = getCompatibleUILibraries(["astro"], "react").includes(uiLibrary);
+		if (isAstroNonReact && supportsAstroReact) {
+			incompatibilityError({
+				message: `UI library '${uiLibrary}' requires React.`,
+				provided: {
+					"ui-library": uiLibrary,
+					"astro-integration": astroIntegration || "none"
+				},
+				suggestions: ["Use --astro-integration react", "Choose a different UI library (daisyui, ark-ui)"]
+			});
+			return;
+		}
+		incompatibilityError({
+			message: `UI library '${uiLibrary}' is not compatible with the selected frontend.`,
+			provided: {
+				"ui-library": uiLibrary,
+				frontend: frontends
+			},
+			suggestions: [`Supported choices for this stack: ${compatible.join(", ")}`, "Choose a different UI library"]
+		});
+	}
+}
+/**
+* Validates that a UI library is compatible with the selected CSS framework
+*/
+function validateUILibraryCSSFrameworkCompatibility(uiLibrary, cssFramework) {
+	if (!uiLibrary || uiLibrary === "none") return;
+	if (!cssFramework) return;
+	const supported = getCompatibleCSSFrameworks(uiLibrary);
+	if (!supported.includes(cssFramework)) exitWithError(`UI library '${uiLibrary}' is not compatible with '${cssFramework}' CSS framework. Supported CSS frameworks: ${supported.join(", ")}`);
+}
+/**
+* Gets list of UI libraries compatible with the selected frontend(s)
+*/
+function getCompatibleUILibraries$1(frontends = [], astroIntegration) {
+	return getCompatibleUILibraries(frontends, astroIntegration);
+}
+/**
+* Gets list of CSS frameworks compatible with the selected UI library
+*/
+function getCompatibleCSSFrameworks$1(uiLibrary) {
+	return getCompatibleCSSFrameworks(uiLibrary);
+}
+/**
+* Checks if a frontend has web styling (excludes native-only frontends)
+*/
+function hasWebStyling$1(frontends = []) {
+	return hasWebStyling(frontends);
+}
+
+//#endregion
+export { validateWebDeployFrontendTemplates as C, incompatibilityError as D, constraintError as E, missingRequirementError as O, validateUILibraryFrontendCompatibility as S, validateWorkersCompatibility as T, validateExamplesCompatibility as _, getCompatibleUILibraries$1 as a, validateServerDeployRequiresBackend as b, isExampleChatSdkAllowed$1 as c, requiresChatSdkVercelAI as d, splitFrontends$1 as f, validateApiFrontendCompatibility as g, validateAddonsAgainstFrontends as h, getCompatibleCSSFrameworks$1 as i, isFrontendAllowedWithBackend$1 as l, validateAddonCompatibility$1 as m, ensureSingleWebAndNative as n, hasWebStyling$1 as o, validateAIFrontendCompatibility as p, getCompatibleAddons$1 as r, isExampleAIAllowed$1 as s, allowedApisForFrontends$1 as t, isWebFrontend$1 as u, validatePaymentsCompatibility as v, validateWebDeployRequiresWebFrontend as w, validateUILibraryCSSFrameworkCompatibility as x, validateSelfBackendCompatibility as y };