alepha 0.13.8 → 0.14.1

package/dist/cli/index.js

@@ -1,13 +1,15 @@
+import { createRequire } from "node:module";
 import { join } from "node:path";
-import { $env, $hook, $inject, $module, Alepha, AlephaError, OPTIONS, t } from "alepha";
+import { $atom, $env, $hook, $inject, $module, $use, Alepha, AlephaError, OPTIONS, t } from "alepha";
 import { FileSystemProvider } from "alepha/file";
-import { $command, CliProvider } from "alepha/command";
+import { $command, CliProvider, EnvUtils } from "alepha/command";
 import { $logger } from "alepha/logger";
-import { spawn } from "node:child_process";
+import { exec, spawn } from "node:child_process";
 import { access, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { boot, buildClient, buildServer, copyAssets, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
 import { tsImport } from "tsx/esm/api";
 import { readFileSync } from "node:fs";
+import { promisify } from "node:util";
 import * as os from "node:os";
 
 //#region ../../src/cli/assets/appRouterTs.ts
@@ -115,18 +117,17 @@ run(alepha);
 //#endregion
 //#region ../../src/cli/assets/mainTs.ts
 const mainTs = () => `
-import { Alepha, run } from "alepha";
-import { $logger } from "alepha/logger";
-
-const alepha = Alepha.create();
+import { run } from "alepha";
+import { $route } from "alepha/server";
 
-alepha.with(() => {
-  const log = $logger();
-
-  log.info("Hello from Alepha!");
-});
+class App {
+  root = $route({
+    path: "/",
+    handler: () => "Hello, Alepha!",
+  });
+}
 
-run(alepha);
+run(App);
 `.trim();
 
 //#endregion
@@ -172,6 +173,7 @@ const version = packageJson.version;
 var AlephaCliUtils = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
+	envUtils = $inject(EnvUtils);
 	/**
 	* Execute a command using npx with inherited stdio.
 	*
@@ -455,89 +457,13 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 `.trim();
 	}
 	/**
-	* Prepare Drizzle configuration files for a database provider.
-	*
-	* Creates temporary entities.js and drizzle.config.js files needed
-	* for Drizzle Kit commands to run properly.
+	* Load environment variables from a .env file.
 	*
-	* @param options - Configuration options including kit, provider info, and paths
-	* @returns Path to the generated drizzle.config.js file
+	* Reads the .env file in the specified root directory and sets
+	* the environment variables in process.env.
 	*/
-	async prepareDrizzleConfig(options) {
-		const models = Object.keys(options.kit.getModels(options.provider));
-		const entitiesJs = this.generateEntitiesJs(options.entry, options.providerName, models);
-		const config = {
-			schema: await this.writeConfigFile("entities.js", entitiesJs, options.rootDir),
-			out: `./migrations/${options.providerName}`,
-			dialect: options.dialect,
-			dbCredentials: { url: options.providerUrl }
-		};
-		if (options.dialect === "sqlite") {
-			let url = options.providerUrl;
-			url = url.replace("sqlite://", "").replace("file://", "");
-			url = join(options.rootDir, url);
-			config.dbCredentials = { url };
-		}
-		if (options.providerName === "pglite") config.driver = "pglite";
-		const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
-		return await this.writeConfigFile("drizzle.config.js", drizzleConfigJs, options.rootDir);
-	}
-	async loadEnvFile(root) {
-		const envPath = join(root, ".env");
-		try {
-			const lines = (await readFile(envPath, "utf8")).split("\n");
-			for (const line of lines) {
-				const [key, ...rest] = line.split("=");
-				if (key) {
-					const value = rest.join("=");
-					process.env[key.trim()] = value.trim();
-				}
-			}
-			this.log.debug(`Loaded environment variables from ${envPath}`);
-		} catch {
-			this.log.debug(`No .env file found at ${envPath}, skipping load.`);
-		}
-	}
-	/**
-	* Run a drizzle-kit command for all database providers in an Alepha instance.
-	*
-	* Iterates through all repository providers, prepares Drizzle config for each,
-	* and executes the specified drizzle-kit command.
-	*
-	* @param options - Configuration including command to run, flags, and logging
-	*/
-	async runDrizzleKitCommand(options) {
-		const rootDir = options.root;
-		await this.loadEnvFile(rootDir);
-		this.log.debug(`Using project root: ${rootDir}`);
-		const { alepha, entry } = await this.loadAlephaFromServerEntryFile(rootDir, options.args);
-		const drizzleKitProvider = alepha.inject("DrizzleKitProvider");
-		const repositoryProvider = alepha.inject("RepositoryProvider");
-		const accepted = /* @__PURE__ */ new Set([]);
-		for (const primitive of repositoryProvider.getRepositories()) {
-			const provider = primitive.provider;
-			const providerName = provider.name;
-			const dialect = provider.dialect;
-			if (accepted.has(providerName)) continue;
-			accepted.add(providerName);
-			if (options.provider && options.provider !== providerName) {
-				this.log.debug(`Skipping provider '${providerName}' (filter: ${options.provider})`);
-				continue;
-			}
-			this.log.info("");
-			this.log.info(options.logMessage(providerName, dialect));
-			const drizzleConfigJsPath = await this.prepareDrizzleConfig({
-				kit: drizzleKitProvider,
-				provider,
-				providerName,
-				providerUrl: provider.url,
-				dialect,
-				entry,
-				rootDir
-			});
-			const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
-			await this.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { env: { NODE_OPTIONS: "--import tsx" } });
-		}
+	async loadEnv(root, files = [".env"]) {
+		await this.envUtils.loadEnv(root, files);
 	}
 	async getPackageManager(root, flags) {
 		if (flags?.yarn) return "yarn";
@@ -685,6 +611,227 @@ var BiomeCommands = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/atoms/changelogOptions.ts
+/**
+* Default scopes to ignore in changelog generation.
+* Commits with these scopes won't appear in release notes.
+*/
+const DEFAULT_IGNORE = [
+	"project",
+	"release",
+	"starter",
+	"example",
+	"chore",
+	"ci",
+	"build",
+	"test",
+	"style"
+];
+/**
+* Changelog configuration atom.
+*
+* Configure in `alepha.config.ts`:
+* ```ts
+* import { changelogOptions } from "alepha/cli";
+*
+* alepha.set(changelogOptions, {
+*   ignore: ["project", "release", "chore", "docs"],
+* });
+* ```
+*/
+const changelogOptions = $atom({
+	name: "alepha.changelog",
+	schema: t.object({ ignore: t.optional(t.array(t.string())) }),
+	default: { ignore: DEFAULT_IGNORE }
+});
+
+//#endregion
+//#region ../../src/cli/services/GitMessageParser.ts
+/**
+* Service for parsing git commit messages into structured format.
+*
+* Only parses **conventional commits with a scope**:
+* - `feat(scope): description` → feature
+* - `fix(scope): description` → bug fix
+* - `feat(scope)!: description` → breaking change
+*
+* Commits without scope are ignored, allowing developers to commit
+* work-in-progress changes without polluting release notes:
+* - `cli: work in progress` → ignored (no type)
+* - `fix: quick patch` → ignored (no scope)
+* - `feat(cli): add command` → included
+*/
+var GitMessageParser = class {
+	log = $logger();
+	/**
+	* Parse a git commit line into a structured Commit object.
+	*
+	* **Format:** `type(scope): description` or `type(scope)!: description`
+	*
+	* **Supported types:** feat, fix, docs, refactor, perf, revert
+	*
+	* **Breaking changes:** Use `!` before `:` (e.g., `feat(api)!: remove endpoint`)
+	*
+	* @returns Commit object or null if not matching/ignored
+	*/
+	parseCommit(line, config) {
+		const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
+		if (!match) return null;
+		const [, hash, message] = match;
+		const ignore = config.ignore ?? DEFAULT_IGNORE;
+		const conventionalMatch = message.match(/^(feat|fix|docs|refactor|perf|revert)\(([^)]+)\)(!)?:\s*(.+)$/i);
+		if (!conventionalMatch) return null;
+		const [, type, scope, breakingMark, description] = conventionalMatch;
+		const baseScope = scope.split("/")[0];
+		if (ignore.includes(baseScope) || ignore.includes(scope)) return null;
+		const breaking = breakingMark === "!" || description.toLowerCase().includes("breaking");
+		return {
+			hash: hash.substring(0, 8),
+			type: type.toLowerCase(),
+			scope,
+			description: description.trim(),
+			breaking
+		};
+	}
+};
+
+//#endregion
+//#region ../../src/cli/commands/ChangelogCommands.ts
+const execAsync = promisify(exec);
+/**
+* Git provider for executing git commands.
+* Can be substituted in tests with a mock implementation.
+*/
+var GitProvider = class {
+	async exec(cmd, cwd) {
+		const { stdout } = await execAsync(`git ${cmd}`, { cwd });
+		return stdout;
+	}
+};
+/**
+* Changelog command for generating release notes from git commits.
+*
+* Usage:
+* - `alepha changelog` - Show unreleased changes since latest tag to HEAD
+* - `alepha changelog --from=1.0.0` - Show changes from version to HEAD
+* - `alepha changelog --from=1.0.0 --to=1.1.0` - Show changes between two refs
+* - `alepha changelog | tee -a CHANGELOG.md` - Append to file
+*/
+var ChangelogCommands = class {
+	log = $logger();
+	git = $inject(GitProvider);
+	parser = $inject(GitMessageParser);
+	config = $use(changelogOptions);
+	/**
+	* Format a single commit line.
+	* Example: `- **cli**: add new command (\`abc1234\`)`
+	*/
+	formatCommit(commit) {
+		return `- **${commit.scope}**: ${commit.description} (\`${commit.hash}\`)`;
+	}
+	/**
+	* Format the changelog entry with sections.
+	*/
+	formatEntry(entry) {
+		const sections = [];
+		if (entry.breaking.length > 0) {
+			sections.push("### Breaking Changes\n");
+			for (const commit of entry.breaking) sections.push(this.formatCommit(commit));
+			sections.push("");
+		}
+		if (entry.features.length > 0) {
+			sections.push("### Features\n");
+			for (const commit of entry.features) sections.push(this.formatCommit(commit));
+			sections.push("");
+		}
+		if (entry.fixes.length > 0) {
+			sections.push("### Bug Fixes\n");
+			for (const commit of entry.fixes) sections.push(this.formatCommit(commit));
+			sections.push("");
+		}
+		return sections.join("\n");
+	}
+	/**
+	* Parse git log output into a changelog entry.
+	*/
+	parseCommits(commitsOutput) {
+		const entry = {
+			features: [],
+			fixes: [],
+			breaking: []
+		};
+		for (const line of commitsOutput.trim().split("\n")) {
+			if (!line.trim()) continue;
+			const commit = this.parser.parseCommit(line, this.config);
+			if (!commit) {
+				this.log.trace("Skipping commit", { line });
+				continue;
+			}
+			this.log.trace("Parsed commit", { commit });
+			if (commit.breaking) entry.breaking.push(commit);
+			if (commit.type === "feat") entry.features.push(commit);
+			else if (commit.type === "fix") entry.fixes.push(commit);
+		}
+		return entry;
+	}
+	/**
+	* Check if entry has any public commits.
+	*/
+	hasChanges(entry) {
+		return entry.features.length > 0 || entry.fixes.length > 0 || entry.breaking.length > 0;
+	}
+	/**
+	* Get the latest version tag.
+	*/
+	async getLatestTag(git) {
+		return (await git("tag --sort=-version:refname")).trim().split("\n").filter((tag) => tag.match(/^\d+\.\d+\.\d+$/))[0] || null;
+	}
+	changelog = $command({
+		name: "changelog",
+		description: "Generate changelog from conventional commits (outputs to stdout)",
+		flags: t.object({
+			from: t.optional(t.string({
+				aliases: ["f"],
+				description: "Starting ref (default: latest tag)"
+			})),
+			to: t.optional(t.string({
+				aliases: ["t"],
+				description: "Ending ref (default: HEAD)"
+			}))
+		}),
+		handler: async ({ flags, root }) => {
+			const git = (cmd) => this.git.exec(cmd, root);
+			let fromRef;
+			if (flags.from) {
+				fromRef = flags.from;
+				this.log.debug("Using specified from ref", { from: fromRef });
+			} else {
+				const latestTag = await this.getLatestTag(git);
+				if (!latestTag) {
+					process.stdout.write("No version tags found in repository\n");
+					return;
+				}
+				fromRef = latestTag;
+				this.log.debug("Using latest tag", { from: fromRef });
+			}
+			const toRef = flags.to || "HEAD";
+			this.log.debug("Using to ref", { to: toRef });
+			const commitsOutput = await git(`log ${fromRef}..${toRef} --oneline`);
+			if (!commitsOutput.trim()) {
+				process.stdout.write(`No changes in range ${fromRef}..${toRef}\n`);
+				return;
+			}
+			const entry = this.parseCommits(commitsOutput);
+			if (!this.hasChanges(entry)) {
+				process.stdout.write(`No public changes in range ${fromRef}..${toRef}\n`);
+				return;
+			}
+			process.stdout.write(this.formatEntry(entry));
+		}
+	});
+};
+
 //#endregion
 //#region ../../src/cli/commands/CoreCommands.ts
 var CoreCommands = class {
@@ -768,9 +915,93 @@ var CoreCommands = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/commands/DeployCommands.ts
+var DeployCommands = class {
+	log = $logger();
+	utils = $inject(AlephaCliUtils);
+	/**
+	* Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)
+	*
+	* Deploy command can be overridden by creating a alepha.config.ts in the project root:
+	*
+	* ```ts
+	* import { defineConfig } from "alepha/cli";
+	*
+	* export default defineConfig({
+	*   commands: {
+	*     deploy: {
+	*       handler: async ({ root, mode, flags }) => {
+	*         // Custom deployment logic here
+	*       },
+	*     },
+	*   },
+	* });
+	* ```
+	*/
+	deploy = $command({
+		name: "deploy",
+		description: "Deploy the project to a hosting platform (e.g., Vercel, Cloudflare, Surge)",
+		mode: true,
+		flags: t.object({
+			build: t.boolean({
+				description: "Build the project before deployment",
+				default: false
+			}),
+			migrate: t.boolean({
+				description: "Run database migrations before deployment (if applicable)",
+				default: false
+			})
+		}),
+		env: t.object({
+			VERCEL_TOKEN: t.optional(t.text({ description: "Vercel API token (e.g., xxxxxxxxxxxxxxxxxxxx)" })),
+			VERCEL_ORG_ID: t.optional(t.text({ description: "Vercel organization ID (e.g., team_abc123...)" })),
+			VERCEL_PROJECT_ID: t.optional(t.text({ description: "Vercel project ID (e.g., prj_abc123...)" })),
+			CLOUDFLARE_API_TOKEN: t.optional(t.text({ description: "Cloudflare API token (e.g., xxxx-xxxx-xxxx-xxxx)" })),
+			CLOUDFLARE_ACCOUNT_ID: t.optional(t.text({ description: "Cloudflare account ID (e.g., abc123def456...)" }))
+		}),
+		handler: async ({ root, mode, flags }) => {
+			if (flags.build) await this.utils.exec("alepha build");
+			if (await this.utils.exists(root, "dist/vercel.json")) {
+				if (flags.migrate) {
+					this.log.debug("Running database migrations before deployment...");
+					await this.utils.exec(`alepha db migrate --mode=${mode}`);
+				}
+				await this.utils.ensureDependency(root, "vercel", { dev: true });
+				const command = `vercel . --cwd=dist ${mode === "production" ? "--prod" : ""}`.trim();
+				this.log.debug(`Deploying to Vercel with command: ${command}`);
+				await this.utils.exec(command);
+				return;
+			}
+			if (await this.utils.exists(root, "dist/wrangler.jsonc")) {
+				if (flags.migrate) {
+					this.log.debug("Running database migrations before deployment...");
+					await this.utils.exec(`alepha db migrate --mode=${mode}`);
+				}
+				await this.utils.ensureDependency(root, "wrangler", { dev: true });
+				const command = `wrangler deploy ${mode === "production" ? "" : "--env preview"} --config=dist/wrangler.jsonc`.trim();
+				this.log.info(`Deploying to Cloudflare with command: ${command}`);
+				await this.utils.exec(command);
+				return;
+			}
+			if (await this.utils.exists(root, "dist/public/404.html")) {
+				await this.utils.ensureDependency(root, "surge", { dev: true });
+				const distPath = join(root, "dist/public");
+				this.log.debug(`Deploying to Surge from directory: ${distPath}`);
+				await this.utils.exec(`surge ${distPath}`);
+				return;
+			}
+			throw new AlephaError("No deployment configuration found in the dist folder.");
+		}
+	});
+};
+
 //#endregion
 //#region ../../src/cli/commands/DrizzleCommands.ts
-const drizzleCommandFlags = t.object({ provider: t.optional(t.text({ description: "Database provider name to target (e.g., 'postgres', 'sqlite')" })) });
+const drizzleCommandFlags = t.object({
+	provider: t.optional(t.text({ description: "Database provider name to target (e.g., 'postgres', 'sqlite')" })),
+	mode: t.optional(t.text({ description: "Environment variable file(s) to load (e.g., 'production' to load .env.production) https://vite.dev/guide/env-and-mode" }))
+});
 var DrizzleCommands = class {
 	log = $logger();
 	utils = $inject(AlephaCliUtils);
@@ -778,7 +1009,7 @@ var DrizzleCommands = class {
 	* Check if database migrations are up to date.
 	*/
 	check = $command({
-		name: "db:check-migrations",
+		name: "check-migrations",
 		description: "Check if database migration files are up to date",
 		args: t.optional(t.text({
 			title: "path",
@@ -845,7 +1076,7 @@ var DrizzleCommands = class {
 	* - Invokes Drizzle Kit's CLI to generate migration files based on the current schema.
 	*/
 	generate = $command({
-		name: "db:generate",
+		name: "generate",
 		description: "Generate migration files based on current database schema",
 		summary: false,
 		args: t.optional(t.text({
@@ -855,12 +1086,13 @@ var DrizzleCommands = class {
 		flags: t.extend(drizzleCommandFlags, { custom: t.optional(t.text({ description: "Custom migration name for drizzle-kit generate --custom" })) }),
 		handler: async ({ args, flags, root }) => {
 			const commandFlags = flags.custom ? `--custom=${flags.custom}` : void 0;
-			await this.utils.runDrizzleKitCommand({
+			await this.runDrizzleKitCommand({
 				root,
 				args,
 				command: "generate",
 				commandFlags,
 				provider: flags.provider,
+				env: flags.mode,
 				logMessage: (providerName, dialect) => `Generate '${providerName}' migrations (${dialect}) ...`
 			});
 		}
@@ -874,7 +1106,7 @@ var DrizzleCommands = class {
 	* - Invokes Drizzle Kit's push command to apply schema changes directly.
 	*/
 	push = $command({
-		name: "db:push",
+		name: "push",
 		description: "Push database schema changes directly to the database",
 		summary: false,
 		args: t.optional(t.text({
@@ -883,11 +1115,12 @@ var DrizzleCommands = class {
 		})),
 		flags: drizzleCommandFlags,
 		handler: async ({ root, args, flags }) => {
-			await this.utils.runDrizzleKitCommand({
+			await this.runDrizzleKitCommand({
 				root,
 				args,
 				command: "push",
 				provider: flags.provider,
+				env: flags.mode,
 				logMessage: (providerName, dialect) => `Push '${providerName}' schema (${dialect}) ...`
 			});
 		}
@@ -901,7 +1134,7 @@ var DrizzleCommands = class {
 	* - Invokes Drizzle Kit's migrate command to apply pending migrations.
 	*/
 	migrate = $command({
-		name: "db:migrate",
+		name: "migrate",
 		description: "Apply pending database migrations",
 		summary: false,
 		args: t.optional(t.text({
@@ -910,11 +1143,12 @@ var DrizzleCommands = class {
 		})),
 		flags: drizzleCommandFlags,
 		handler: async ({ root, args, flags }) => {
-			await this.utils.runDrizzleKitCommand({
+			await this.runDrizzleKitCommand({
 				root,
 				args,
 				command: "migrate",
 				provider: flags.provider,
+				env: flags.mode,
 				logMessage: (providerName, dialect) => `Migrate '${providerName}' database (${dialect}) ...`
 			});
 		}
@@ -928,7 +1162,7 @@ var DrizzleCommands = class {
 	* - Invokes Drizzle Kit's studio command to launch the web-based database browser.
 	*/
 	studio = $command({
-		name: "db:studio",
+		name: "studio",
 		description: "Launch Drizzle Studio database browser",
 		summary: false,
 		args: t.optional(t.text({
@@ -937,15 +1171,120 @@ var DrizzleCommands = class {
 		})),
 		flags: drizzleCommandFlags,
 		handler: async ({ root, args, flags }) => {
-			await this.utils.runDrizzleKitCommand({
+			await this.runDrizzleKitCommand({
 				root,
 				args,
 				command: "studio",
 				provider: flags.provider,
+				env: flags.mode,
 				logMessage: (providerName, dialect) => `Launch Studio for '${providerName}' (${dialect}) ...`
 			});
 		}
 	});
+	/**
+	* Parent command for database operations.
+	*/
+	db = $command({
+		name: "db",
+		description: "Database management commands",
+		children: [
+			this.check,
+			this.generate,
+			this.push,
+			this.migrate,
+			this.studio
+		],
+		handler: async ({ help }) => {
+			help();
+		}
+	});
+	/**
+	* Run a drizzle-kit command for all database providers in an Alepha instance.
+	*
+	* Iterates through all repository providers, prepares Drizzle config for each,
+	* and executes the specified drizzle-kit command.
+	*
+	* @param options - Configuration including command to run, flags, and logging
+	*/
+	async runDrizzleKitCommand(options) {
+		const rootDir = options.root;
+		const envFiles = [".env"];
+		if (options.env) envFiles.push(`.env.${options.env}`);
+		await this.utils.loadEnv(rootDir, envFiles);
+		this.log.debug(`Using project root: ${rootDir}`);
+		const { alepha, entry } = await this.utils.loadAlephaFromServerEntryFile(rootDir, options.args);
+		const drizzleKitProvider = alepha.inject("DrizzleKitProvider");
+		const repositoryProvider = alepha.inject("RepositoryProvider");
+		const accepted = /* @__PURE__ */ new Set([]);
+		for (const primitive of repositoryProvider.getRepositories()) {
+			const provider = primitive.provider;
+			const providerName = provider.name;
+			const dialect = provider.dialect;
+			if (accepted.has(providerName)) continue;
+			accepted.add(providerName);
+			if (options.provider && options.provider !== providerName) {
+				this.log.debug(`Skipping provider '${providerName}' (filter: ${options.provider})`);
+				continue;
+			}
+			this.log.info("");
+			this.log.info(options.logMessage(providerName, dialect));
+			const drizzleConfigJsPath = await this.prepareDrizzleConfig({
+				kit: drizzleKitProvider,
+				provider,
+				providerName,
+				providerUrl: provider.url,
+				dialect,
+				entry,
+				rootDir
+			});
+			const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
+			await this.utils.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { env: { NODE_OPTIONS: "--import tsx" } });
+		}
+	}
+	/**
+	* Prepare Drizzle configuration files for a database provider.
+	*
+	* Creates temporary entities.js and drizzle.config.js files needed
+	* for Drizzle Kit commands to run properly.
+	*
+	* @param options - Configuration options including kit, provider info, and paths
+	* @returns Path to the generated drizzle.config.js file
+	*/
+	async prepareDrizzleConfig(options) {
+		const models = Object.keys(options.kit.getModels(options.provider));
+		const entitiesJs = this.utils.generateEntitiesJs(options.entry, options.providerName, models);
+		const config = {
+			schema: await this.utils.writeConfigFile("entities.js", entitiesJs, options.rootDir),
+			out: `./migrations/${options.providerName}`,
+			dialect: options.dialect,
+			dbCredentials: { url: options.providerUrl }
+		};
+		if (options.provider.schema) config.schemaFilter = options.provider.schema;
+		if (options.providerName === "d1") config.driver = "d1-http";
+		if (options.providerName === "pglite") config.driver = "pglite";
+		if (options.dialect === "sqlite") if (options.providerName === "d1") {
+			const token = process.env.CLOUDFLARE_API_TOKEN;
+			if (!token) throw new AlephaError("CLOUDFLARE_API_TOKEN environment variable is not set. https://orm.drizzle.team/docs/guides/d1-http-with-drizzle-kit");
+			const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+			if (!accountId) throw new AlephaError("CLOUDFLARE_ACCOUNT_ID environment variable is not set. https://orm.drizzle.team/docs/guides/d1-http-with-drizzle-kit");
+			const url = options.providerUrl;
+			if (!url.startsWith("cloudflare-d1://")) throw new AlephaError("D1 provider URL must start with 'cloudflare-d1://'.");
+			const [, databaseId] = url.replace("cloudflare-d1://", "").replace("cloudflare-d1:", "").split(":");
+			if (!databaseId) throw new AlephaError("Database ID is missing in the D1 provider URL. Cloudflare D1 URL format: cloudflare-d1://<database_name>:<database_id>");
+			config.dbCredentials = {
+				accountId,
+				databaseId,
+				token
+			};
+		} else {
+			let url = options.providerUrl;
+			url = url.replace("sqlite://", "").replace("file://", "");
+			url = join(options.rootDir, url);
+			config.dbCredentials = { url };
+		}
+		const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
+		return await this.utils.writeConfigFile("drizzle.config.js", drizzleConfigJs, options.rootDir);
+	}
 };
 
 //#endregion
@@ -1067,11 +1406,11 @@ var ViteCommands = class {
 			vercel: t.optional(t.boolean({ description: "Generate Vercel deployment configuration" })),
 			cloudflare: t.optional(t.boolean({ description: "Generate Cloudflare Workers configuration" })),
 			docker: t.optional(t.boolean({ description: "Generate Docker configuration" })),
-			sitemap: t.optional(t.text({ description: "Generate sitemap.xml with base URL" })),
-			prerender: t.optional(t.boolean({ description: "Pre-render static pages" }))
+			sitemap: t.optional(t.text({ description: "Generate sitemap.xml with base URL" }))
 		}),
 		handler: async ({ flags, args, run, root }) => {
 			process.env.ALEPHA_BUILD_MODE = "cli";
+			process.env.NODE_ENV = "production";
 			if (await this.utils.hasExpo(root)) return;
 			await this.utils.ensureConfig(root, {
 				viteConfigTs: true,
@@ -1083,7 +1422,8 @@ var ViteCommands = class {
 			const clientDir = "public";
 			await this.utils.ensureDependency(root, "vite", { run });
 			await run.rm("dist", { alias: "clean dist" });
-			const viteAlephaBuildOptions = (await import(join(root, "vite.config.ts")))?.default?.plugins.find((it) => !!it[OPTIONS])?.[OPTIONS] ?? {};
+			const viteAlephaBuildOptions = (await createRequire(import.meta.url)("vite").resolveConfig({}, "build", "production")).plugins.find((it) => it.name === "alepha:build")?.[OPTIONS] || {};
+			await this.utils.loadEnv(root, [".env", ".env.production"]);
 			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
 			const hasServer = viteAlephaBuildOptions.serverEntry !== false;
 			let hasClient = false;
@@ -1091,12 +1431,14 @@ var ViteCommands = class {
 				await access(join(root, "index.html"));
 				hasClient = true;
 			} catch {}
+			const clientOptions = typeof viteAlephaBuildOptions.client === "object" ? viteAlephaBuildOptions.client : {};
 			if (hasClient) await run({
 				name: "vite build client",
 				handler: () => buildClient({
 					silent: true,
 					dist: `${distDir}/${clientDir}`,
-					stats
+					stats,
+					precompress: clientOptions.precompress
 				})
 			});
 			await run({
@@ -1124,7 +1466,7 @@ var ViteCommands = class {
 				run
 			});
 			if (hasClient) {
-				const sitemapBaseUrl = flags.sitemap ?? (typeof viteAlephaBuildOptions.client === "object" ? viteAlephaBuildOptions.client.sitemap?.hostname : void 0);
+				const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
 				if (sitemapBaseUrl) await run({
 					name: "add sitemap",
 					handler: async () => {
@@ -1134,12 +1476,13 @@ var ViteCommands = class {
 						}));
 					}
 				});
-				if (flags.prerender ?? (typeof viteAlephaBuildOptions.client === "object" ? viteAlephaBuildOptions.client.prerender : false)) await run({
+				if (clientOptions.prerender) await run({
 					name: "pre-render pages",
 					handler: async () => {
 						await prerenderPages({
 							dist: `${distDir}/${clientDir}`,
-							entry: `${distDir}/index.js`
+							entry: `${distDir}/index.js`,
+							compress: clientOptions.precompress
 						});
 					}
 				});
@@ -1155,10 +1498,16 @@ var ViteCommands = class {
 					})
 				});
 			}
-			if (flags.cloudflare || viteAlephaBuildOptions.cloudflare) await run({
-				name: "add Cloudflare config",
-				handler: () => generateCloudflare({ distDir })
-			});
+			if (flags.cloudflare || viteAlephaBuildOptions.cloudflare) {
+				const config = typeof viteAlephaBuildOptions.cloudflare === "boolean" ? {} : viteAlephaBuildOptions.cloudflare;
+				await run({
+					name: "add Cloudflare config",
+					handler: () => generateCloudflare({
+						distDir,
+						config
+					})
+				});
+			}
 			if (flags.docker || viteAlephaBuildOptions.docker) {
 				const dockerConfig = typeof viteAlephaBuildOptions.docker === "object" ? viteAlephaBuildOptions.docker : {};
 				await run({
@@ -1174,13 +1523,22 @@ var ViteCommands = class {
 	test = $command({
 		name: "test",
 		description: "Run tests using Vitest",
-		handler: async ({ root }) => {
+		flags: t.object({ config: t.optional(t.string({
+			description: "Path to Vitest config file",
+			alias: "c"
+		})) }),
+		env: t.object({ VITEST_ARGS: t.optional(t.string({
+			default: "",
+			description: "Additional arguments to pass to Vitest. E.g., --coverage"
+		})) }),
+		handler: async ({ root, flags, env }) => {
 			await this.utils.ensureConfig(root, {
 				tsconfigJson: true,
 				viteConfigTs: true
 			});
 			await this.utils.ensureDependency(root, "vitest");
-			await this.utils.exec(`vitest run ${this.env.VITEST_ARGS}`);
+			const config = flags.config ? `--config=${flags.config}` : "";
+			await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
 		}
 	});
 };
@@ -1197,7 +1555,7 @@ var AlephaCliExtension = class {
 			if (!await this.fs.exists(extensionPath)) return;
 			const { default: Extension } = await import(extensionPath);
 			if (typeof Extension !== "function") return;
-			this.alepha.with(Extension);
+			this.alepha.inject(Extension, { args: [this.alepha] });
 		}
 	});
 };
@@ -1205,11 +1563,13 @@ const AlephaCli = $module({
 	name: "alepha.cli",
 	services: [
 		AlephaCliExtension,
+		BiomeCommands,
+		ChangelogCommands,
 		CoreCommands,
+		DeployCommands,
 		DrizzleCommands,
 		VerifyCommands,
-		ViteCommands,
-		BiomeCommands
+		ViteCommands
 	]
 });
 
@@ -1251,11 +1611,10 @@ var AlephaPackageBuilderCli = class {
 			const tmpDir = join(root, "node_modules/.alepha");
 			await this.fs.mkdir(tmpDir, { recursive: true }).catch(() => {});
 			await this.fs.writeFile(join(tmpDir, "module-dependencies.json"), JSON.stringify(modules, null, 2));
-			const external = [
-				"alepha",
-				packageName,
-				...modules.map((item) => `${packageName}/${item.name.replace("-", "/").replace("/core", "")}`)
-			];
+			const tsconfig = await readFile(join(root, "../../tsconfig.json"), "utf-8");
+			const external = Object.keys(JSON.parse(tsconfig).compilerOptions.paths);
+			external.push("bun");
+			external.push("bun:sqlite");
 			await run.rm(this.dist);
 			const build = async (item) => {
 				const entries = [];
@@ -1268,7 +1627,11 @@ var AlephaPackageBuilderCli = class {
 					sourcemap: true,
 					fixedExtension: false,
 					platform: "node",
-					external
+					external,
+					dts: {
+						sourcemap: true,
+						resolve: false
+					}
 				});
 				if (item.native) entries.push({
 					entry: join(src, "index.native.ts"),
@@ -1401,5 +1764,14 @@ async function analyzeModules(srcDir, packageName) {
 }
 
 //#endregion
-export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BiomeCommands, CoreCommands, DrizzleCommands, VerifyCommands, ViteCommands, analyzeModules, version };
+//#region ../../src/cli/defineConfig.ts
+const defineConfig = (config) => {
+	return (alepha) => {
+		const { commands } = config(alepha);
+		return { ...commands };
+	};
+};
+
+//#endregion
+export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BiomeCommands, ChangelogCommands, CoreCommands, DEFAULT_IGNORE, DeployCommands, DrizzleCommands, GitMessageParser, GitProvider, VerifyCommands, ViteCommands, analyzeModules, changelogOptions, defineConfig, version };
 //# sourceMappingURL=index.js.map