create-better-t-stack 3.5.0 → 3.5.2

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as createBtsCli } from "./src-C46pe-uS.js";
+import { n as createBtsCli } from "./src-C_MeUxmG.js";
 
 //#region src/cli.ts
 createBtsCli().run();

package/dist/index.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { a as router, i as init, n as createBtsCli, o as sponsors, r as docs, t as builder } from "./src-C46pe-uS.js";
+import { a as router, i as init, n as createBtsCli, o as sponsors, r as docs, t as builder } from "./src-C_MeUxmG.js";
 
 export { builder, createBtsCli, docs, init, router, sponsors };

package/dist/{src-C46pe-uS.js → src-C_MeUxmG.js}

@@ -2689,6 +2689,38 @@ handlebars.registerHelper("or", (...args) => {
 });
 handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
 
+//#endregion
+//#region src/helpers/deployment/alchemy/env-dts-setup.ts
+const tsProject$1 = new Project({
+	useInMemoryFileSystem: false,
+	skipAddingFilesFromTsConfig: true
+});
+function determineImportPath(envDtsPath, projectDir, config) {
+	const { webDeploy, serverDeploy, backend } = config;
+	const isBackendSelf = backend === "self";
+	let alchemyRunPath;
+	if (webDeploy === "alchemy" && (serverDeploy === "alchemy" || isBackendSelf)) if (isBackendSelf) alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
+	else alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
+	else if (webDeploy === "alchemy") alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
+	else if (serverDeploy === "alchemy") alchemyRunPath = path.join(projectDir, "apps/server/alchemy.run.ts");
+	else alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
+	const relativePath = path.relative(path.dirname(envDtsPath), alchemyRunPath.replace(/\.ts$/, ""));
+	return (relativePath.startsWith(".") ? relativePath : `./${relativePath}`).replace(/\\/g, "/");
+}
+async function setupEnvDtsImport(envDtsPath, projectDir, config) {
+	if (!await fs.pathExists(envDtsPath)) return;
+	const importPath = determineImportPath(envDtsPath, projectDir, config);
+	const sourceFile = tsProject$1.addSourceFileAtPath(envDtsPath);
+	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === importPath && imp.getNamedImports().some((named) => named.getName() === "server"))) sourceFile.insertImportDeclaration(0, {
+		moduleSpecifier: importPath,
+		namedImports: [{
+			name: "server",
+			isTypeOnly: true
+		}]
+	});
+	await sourceFile.save();
+}
+
 //#endregion
 //#region src/helpers/core/template-manager.ts
 async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
@@ -3194,7 +3226,9 @@ async function setupDeploymentTemplates(projectDir, context) {
 				const serverAppDir = path.join(projectDir, "apps/server");
 				if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(serverAppDir)) {
 					await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
-					await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+					const envDtsPath = path.join(serverAppDir, "env.d.ts");
+					await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
+					await setupEnvDtsImport(envDtsPath, projectDir, context);
 					await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
 				}
 			}
@@ -3234,10 +3268,18 @@ async function addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc) {
 		"packages/db"
 	]) {
 		const packageDir = path.join(projectDir, packageName);
-		if (await fs.pathExists(packageDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, packageDir, context);
+		if (await fs.pathExists(packageDir)) {
+			const envDtsPath = path.join(packageDir, "env.d.ts");
+			await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
+			await setupEnvDtsImport(envDtsPath, projectDir, context);
+		}
 	}
 	const serverAppDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverAppDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+	if (await fs.pathExists(serverAppDir)) {
+		const envDtsPath = path.join(serverAppDir, "env.d.ts");
+		await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
+		await setupEnvDtsImport(envDtsPath, projectDir, context);
+	}
 }
 
 //#endregion
@@ -5987,7 +6029,7 @@ function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSet
 	if (database === "none") return "";
 	const isBackendSelf = backend === "self";
 	const envPath = isBackendSelf ? "apps/web/.env" : "apps/server/.env";
-	const dbLocalPath = isBackendSelf ? "apps/web" : "apps/server";
+	const dbLocalPath = "packages/db";
 	let setup = "## Database Setup\n\n";
 	if (database === "sqlite") setup += `This project uses SQLite${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
 
@@ -6049,7 +6091,7 @@ function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNati
 - \`${packageManagerRunCmd} db:push\`: Push schema changes to database
 - \`${packageManagerRunCmd} db:studio\`: Open database studio UI`;
 		if (database === "sqlite" && orm === "drizzle") scripts += `
-- \`cd ${isBackendSelf ? "apps/web" : "apps/server"} && ${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
+- \`cd packages/db && ${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
 	}
 	if (addons.includes("biome")) scripts += `
 - \`${packageManagerRunCmd} check\`: Run Biome formatting and linting`;
@@ -6292,9 +6334,9 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 		}
 	}
 	if (dbSetup === "d1" && serverDeploy === "alchemy") {
-		if (orm === "drizzle") instructions.push(`${pc.yellow("NOTE:")} D1 migrations are automatically handled by Alchemy`);
+		if (orm === "drizzle") instructions.push(`${pc.cyan("•")} Generate migrations: ${`${runCmd} db:generate`}`);
 		else if (orm === "prisma") {
-			instructions.push(`${pc.cyan("•")} Generate migrations: ${`${runCmd} db:generate`}`);
+			instructions.push(`${pc.cyan("•")} Generate Prisma client: ${`${runCmd} db:generate`}`);
 			instructions.push(`${pc.cyan("•")} Apply migrations: ${`${runCmd} db:migrate`}`);
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "type": "module",
   "license": "MIT",

package/templates/deploy/alchemy/alchemy.run.ts.hbs

@@ -21,7 +21,6 @@ import { Worker } from "alchemy/cloudflare";
 {{/if}}
 {{#if (and (or (eq serverDeploy "alchemy") (and (eq webDeploy "alchemy") (eq backend "self"))) (eq dbSetup "d1"))}}
 import { D1Database } from "alchemy/cloudflare";
-import { Exec } from "alchemy/os";
 {{/if}}
 import { config } from "dotenv";
 
@@ -36,11 +35,6 @@ config({ path: "./.env" });
 const app = await alchemy("{{projectName}}");
 
 {{#if (and (or (eq serverDeploy "alchemy") (and (eq webDeploy "alchemy") (eq backend "self"))) (eq dbSetup "d1"))}}
-await Exec("db-generate", {
-	{{#if (and (eq webDeploy "alchemy") (eq serverDeploy "alchemy"))}}cwd: "packages/db",{{/if}}
-	command: "{{packageManager}} run db:generate",
-});
-
 const db = await D1Database("database", {
 	{{#if (eq orm "prisma")}}
 	migrationsDir: "packages/db/prisma/migrations",

package/templates/deploy/alchemy/env.d.ts.hbs

@@ -1,12 +1,6 @@
 // This file infers types for the cloudflare:workers environment from your Alchemy Worker.
 // @see https://alchemy.run/concepts/bindings/#type-safe-bindings
 
-{{#if (eq webDeploy "alchemy")}}
-import type { server } from "../../alchemy.run";
-{{else}}
-import type { server } from "./alchemy.run";
-{{/if}}
-
 export type CloudflareEnv = typeof server.Env;
 
 declare global {