alepha 0.13.7 → 0.14.0

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 { FileSystemProvider } from "alepha/file";
 import { $command, CliProvider } 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
@@ -272,6 +273,13 @@ var AlephaCliUtils = class {
 	generatePackageJsonContent(modes) {
 		const dependencies = { alepha: `^${version}` };
 		const devDependencies = {};
+		const scripts = {
+			dev: "alepha dev",
+			build: "alepha build",
+			lint: "alepha lint",
+			typecheck: "alepha typecheck",
+			verify: "alepha verify"
+		};
 		if (modes.ui) {
 			dependencies["@alepha/ui"] = `^${version}`;
 			modes.react = true;
@@ -286,11 +294,7 @@ var AlephaCliUtils = class {
 			type: "module",
 			dependencies,
 			devDependencies,
-			scripts: {
-				dev: "alepha dev",
-				build: "alepha build",
-				verify: "alepha verify"
-			}
+			scripts
 		};
 	}
 	/**
@@ -309,8 +313,9 @@ var AlephaCliUtils = class {
 		try {
 			await access(packageJsonPath);
 		} catch (error) {
-			await writeFile(packageJsonPath, JSON.stringify(this.generatePackageJsonContent(modes), null, 2));
-			return;
+			const obj = this.generatePackageJsonContent(modes);
+			await writeFile(packageJsonPath, JSON.stringify(obj, null, 2));
+			return obj;
 		}
 		const content = await readFile(packageJsonPath, "utf8");
 		const packageJson$1 = JSON.parse(content);
@@ -323,6 +328,7 @@ var AlephaCliUtils = class {
 		Object.assign(packageJson$1.devDependencies, newPackageJson.devDependencies);
 		Object.assign(packageJson$1.scripts, newPackageJson.scripts);
 		await writeFile(packageJsonPath, JSON.stringify(packageJson$1, null, 2));
+		return packageJson$1;
 	}
 	async ensureConfig(root, opts) {
 		const tasks = [];
@@ -332,7 +338,7 @@ var AlephaCliUtils = class {
 		if (opts.indexHtml) tasks.push(this.ensureIndexHtml(root));
 		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
 		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
-		await Promise.all(tasks);
+		return await Promise.all(tasks);
 	}
 	/**
 	* Ensure tsconfig.json exists in the project.
@@ -450,88 +456,27 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 `.trim();
 	}
 	/**
-	* Prepare Drizzle configuration files for a database provider.
+	* Load environment variables from a .env file.
 	*
-	* 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
+	* 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();
+	async loadEnvFile(root, files = [".env"]) {
+		for (const it of files) for (const file of [it, `${it}.local`]) {
+			const envPath = join(root, file);
+			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 ${file} file found at ${envPath}, skipping load.`);
 			}
-			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 getPackageManager(root, flags) {
@@ -615,6 +560,15 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 		}
 	}
 	/**
+	* Check if Expo is present in the project.
+	*
+	* @param root - The root directory of the project
+	* @returns True if expo is in dependencies or devDependencies
+	*/
+	async hasExpo(root) {
+		return this.hasDependency(root, "expo");
+	}
+	/**
 	* Install a dependency if it's missing from the project.
 	*
 	* Automatically detects the package manager (yarn, pnpm, npm) and installs
@@ -671,6 +625,231 @@ var BiomeCommands = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/commands/ChangelogCommands.ts
+const execAsync = promisify(exec);
+const DEFAULT_IGNORE = [
+	"project",
+	"release",
+	"starter",
+	"example",
+	"chore",
+	"ci",
+	"build",
+	"test",
+	"style"
+];
+function parseCommit(line, config) {
+	const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
+	if (!match) return null;
+	const [, hash, message] = match;
+	const breaking = message.includes("!:") || message.toLowerCase().includes("breaking");
+	const ignore = config.ignore ?? DEFAULT_IGNORE;
+	const conventionalMatch = message.match(/^(feat|fix|docs|refactor|perf|revert)(?:\(([^)]+)\))?!?:\s*(.+)$/i);
+	if (conventionalMatch) {
+		const [, type, scope, description] = conventionalMatch;
+		if (scope) {
+			const baseScope = scope.split("/")[0];
+			if (ignore.includes(baseScope) || ignore.includes(scope)) return null;
+		}
+		if (!scope && ignore.includes(type.toLowerCase())) return null;
+		return {
+			hash: hash.substring(0, 8),
+			type: type.toLowerCase(),
+			scope: scope || null,
+			description: description.trim(),
+			breaking
+		};
+	}
+	const moduleMatch = message.match(/^([a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)?):\s*(.+)$/i);
+	if (moduleMatch) {
+		const [, module, description] = moduleMatch;
+		const baseModule = module.split("/")[0];
+		if (ignore.includes(baseModule)) return null;
+		if (config.scopes && !config.scopes.includes(baseModule)) return null;
+		const desc = description.toLowerCase();
+		let type = "improve";
+		if (desc.includes("fix") || desc.includes("bug") || desc.includes("issue")) type = "fix";
+		else if (desc.includes("add") || desc.includes("new") || desc.includes("implement")) type = "feat";
+		return {
+			hash: hash.substring(0, 8),
+			type,
+			scope: module,
+			description: description.trim(),
+			breaking
+		};
+	}
+	return null;
+}
+function formatCommit(commit) {
+	return `- ${commit.scope ? `**${commit.scope}**: ` : ""}${commit.description} (\`${commit.hash}\`)`;
+}
+function generateChangelog(entries) {
+	let output = "# Changelog\n\n";
+	output += "All notable changes to this project will be documented in this file.\n\n";
+	for (const entry of entries) {
+		output += `## [${entry.version}] - ${entry.date}\n\n`;
+		output += formatEntry(entry);
+	}
+	return output;
+}
+function formatEntry(entry) {
+	let output = "";
+	if (entry.breaking.length > 0) {
+		output += "### Breaking Changes\n\n";
+		for (const commit of entry.breaking) output += `${formatCommit(commit)}\n`;
+		output += "\n";
+	}
+	if (entry.features.length > 0) {
+		output += "### Features\n\n";
+		for (const commit of entry.features) output += `${formatCommit(commit)}\n`;
+		output += "\n";
+	}
+	if (entry.fixes.length > 0) {
+		output += "### Bug Fixes\n\n";
+		for (const commit of entry.fixes) output += `${formatCommit(commit)}\n`;
+		output += "\n";
+	}
+	return output;
+}
+async function loadConfig(root) {
+	try {
+		const pkgPath = join(root, "package.json");
+		return JSON.parse(await readFile(pkgPath, "utf8")).changelog ?? {};
+	} catch {
+		return {};
+	}
+}
+var ChangelogCommands = class {
+	changelog = $command({
+		name: "changelog",
+		description: "Generate CHANGELOG.md from git commits",
+		flags: t.object({
+			release: t.optional(t.boolean({
+				when: ["--release", "-r"],
+				description: "Output release notes for the latest version only (for GitHub Release)"
+			})),
+			preview: t.optional(t.boolean({
+				when: ["--preview", "-p"],
+				description: "Preview unreleased changes (commits since last tag)"
+			})),
+			output: t.optional(t.string({
+				when: ["--output", "-o"],
+				description: "Output file path (defaults to CHANGELOG.md, use - for stdout)"
+			})),
+			limit: t.optional(t.number({
+				when: ["--limit", "-l"],
+				description: "Limit number of versions to include"
+			}))
+		}),
+		handler: async ({ flags, run, root }) => {
+			const config = await loadConfig(root);
+			const git = async (cmd) => {
+				const { stdout } = await execAsync(`git ${cmd}`, { cwd: root });
+				return stdout;
+			};
+			const tags = (await git("tag --sort=-version:refname")).trim().split("\n").filter((tag) => tag.match(/^\d+\.\d+\.\d+$/));
+			if (tags.length === 0) throw new Error("No version tags found");
+			if (flags.preview) {
+				const latestTag = tags[0];
+				const commitsOutput = await git(`log ${latestTag}..HEAD --oneline`);
+				if (!commitsOutput.trim()) {
+					console.log("No unreleased changes since", latestTag);
+					return;
+				}
+				const entry = {
+					version: "Unreleased",
+					date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+					features: [],
+					fixes: [],
+					docs: [],
+					improvements: [],
+					breaking: []
+				};
+				for (const line of commitsOutput.trim().split("\n")) {
+					if (!line.trim()) continue;
+					const commit = parseCommit(line, config);
+					if (!commit) continue;
+					if (commit.breaking) entry.breaking.push(commit);
+					switch (commit.type) {
+						case "feat":
+							entry.features.push(commit);
+							break;
+						case "fix":
+							entry.fixes.push(commit);
+							break;
+						case "docs":
+							entry.docs.push(commit);
+							break;
+						case "refactor":
+						case "perf":
+						case "improve":
+							entry.improvements.push(commit);
+							break;
+					}
+				}
+				if (!(entry.features.length > 0 || entry.fixes.length > 0 || entry.breaking.length > 0)) {
+					console.log("No public changes since", latestTag);
+					return;
+				}
+				console.log(`## [Unreleased] - since ${latestTag}\n`);
+				console.log(formatEntry(entry));
+				return;
+			}
+			const entries = [];
+			const limit = flags.limit || (flags.release ? 1 : tags.length);
+			for (let i = 0; i < Math.min(limit, tags.length); i++) {
+				const tag = tags[i];
+				const prevTag = tags[i + 1];
+				const date = (await git(`log -1 --format=%ci ${tag}`)).trim().split(" ")[0];
+				const commitsOutput = await git(`log ${prevTag ? `${prevTag}..${tag}` : tag} --oneline`);
+				const entry = {
+					version: tag,
+					date,
+					features: [],
+					fixes: [],
+					docs: [],
+					improvements: [],
+					breaking: []
+				};
+				for (const line of commitsOutput.trim().split("\n")) {
+					if (!line.trim()) continue;
+					const commit = parseCommit(line, config);
+					if (!commit) continue;
+					if (commit.breaking) entry.breaking.push(commit);
+					switch (commit.type) {
+						case "feat":
+							entry.features.push(commit);
+							break;
+						case "fix":
+							entry.fixes.push(commit);
+							break;
+						case "docs":
+							entry.docs.push(commit);
+							break;
+						case "refactor":
+						case "perf":
+						case "improve":
+							entry.improvements.push(commit);
+							break;
+					}
+				}
+				if (entry.features.length > 0 || entry.fixes.length > 0 || entry.breaking.length > 0) entries.push(entry);
+			}
+			if (entries.length === 0) {
+				console.log("No public commits found");
+				return;
+			}
+			let output;
+			if (flags.release) output = formatEntry(entries[0]);
+			else output = generateChangelog(entries);
+			const outputPath = flags.output ?? "CHANGELOG.md";
+			if (outputPath === "-") console.log(output);
+			else await run(`Writing ${outputPath}`, () => writeFile(join(root, outputPath), output, "utf8"));
+		}
+	});
+};
+
 //#endregion
 //#region ../../src/cli/commands/CoreCommands.ts
 var CoreCommands = class {
@@ -722,6 +901,7 @@ var CoreCommands = class {
 		}),
 		handler: async ({ run, flags, root }) => {
 			if (flags.ui) flags.react = true;
+			const isExpo = await this.utils.hasExpo(root);
 			await run({
 				name: "ensuring configuration files",
 				handler: async () => {
@@ -729,9 +909,9 @@ var CoreCommands = class {
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
-						viteConfigTs: true,
+						viteConfigTs: !isExpo,
 						editorconfig: true,
-						indexHtml: !!flags.react
+						indexHtml: !!flags.react && !isExpo
 					});
 					if (!flags.react) await this.utils.ensureSrcMain(root);
 				}
@@ -743,6 +923,8 @@ var CoreCommands = class {
 			} else if (pm === "pnpm") await this.utils.ensurePnpm(root);
 			else await this.utils.ensureNpm(root);
 			await run(`${pm} install`, { alias: `installing dependencies with ${pm}` });
+			if (!isExpo) await this.utils.ensureDependency(root, "vite", { run });
+			await this.utils.ensureDependency(root, "@biomejs/biome", { run });
 			if (flags.test) {
 				await this.utils.ensureTestDir(root);
 				await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
@@ -753,7 +935,10 @@ var CoreCommands = class {
 
 //#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);
@@ -838,12 +1023,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}) ...`
 			});
 		}
@@ -866,11 +1052,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}) ...`
 			});
 		}
@@ -893,11 +1080,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}) ...`
 			});
 		}
@@ -920,15 +1108,102 @@ 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}) ...`
 			});
 		}
 	});
+	/**
+	* 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.loadEnvFile(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.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
@@ -958,7 +1233,7 @@ var VerifyCommands = class {
 			await run("alepha typecheck");
 			if ((await this.utils.readPackageJson(root)).devDependencies?.vitest) await run("alepha test");
 			if (await this.utils.exists(root, "migrations")) await run("alepha db:check-migrations");
-			await run("alepha build");
+			if (!await this.utils.hasExpo(root)) await run("alepha build");
 			await run("alepha clean");
 		}
 	});
@@ -983,6 +1258,7 @@ var ViteCommands = class {
 	env = $env(t.object({ VITEST_ARGS: t.string({ default: "" }) }));
 	run = $command({
 		name: "run",
+		hide: true,
 		description: "Run a TypeScript file directly",
 		flags: t.object({ watch: t.optional(t.boolean({
 			description: "Watch file for changes",
@@ -1012,10 +1288,15 @@ var ViteCommands = class {
 			description: "Filepath to run"
 		})),
 		handler: async ({ args, root }) => {
+			const expo = await this.utils.hasExpo(root);
 			await this.utils.ensureConfig(root, {
-				viteConfigTs: true,
+				viteConfigTs: !expo,
 				tsconfigJson: true
 			});
+			if (expo) {
+				await this.utils.exec(`expo start`);
+				return;
+			}
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			try {
@@ -1049,6 +1330,8 @@ var ViteCommands = class {
 		}),
 		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,
 				tsconfigJson: true
@@ -1059,7 +1342,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.loadEnvFile(root, [".env", ".env.production"]);
 			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
 			const hasServer = viteAlephaBuildOptions.serverEntry !== false;
 			let hasClient = false;
@@ -1067,12 +1351,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({
@@ -1093,15 +1379,14 @@ var ViteCommands = class {
 					if (clientBuilt && hasServer) await unlink(`${distDir}/${clientDir}/index.html`);
 				}
 			});
-			await run({
-				name: "copy assets",
-				handler: () => copyAssets({
-					entry: `${distDir}/index.js`,
-					distDir
-				})
+			await copyAssets({
+				root,
+				entry: `${distDir}/index.js`,
+				distDir,
+				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 () => {
@@ -1111,12 +1396,13 @@ var ViteCommands = class {
 						}));
 					}
 				});
-				if (flags.prerender ?? (typeof viteAlephaBuildOptions.client === "object" ? viteAlephaBuildOptions.client.prerender : false)) await run({
+				if (flags.prerender ?? 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
 						});
 					}
 				});
@@ -1132,10 +1418,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({
@@ -1182,6 +1474,7 @@ const AlephaCli = $module({
 	name: "alepha.cli",
 	services: [
 		AlephaCliExtension,
+		ChangelogCommands,
 		CoreCommands,
 		DrizzleCommands,
 		VerifyCommands,
@@ -1208,7 +1501,9 @@ var AlephaPackageBuilderCli = class {
 			});
 			pkgData.exports = {};
 			for (const item of modules) {
-				const path = item.name === "core" ? "." : `./${item.name.replace("-", "/")}`;
+				let m = `./${item.name.replace("core", "")}`;
+				if (m.endsWith("/")) m = m.slice(0, -1);
+				const path = m;
 				pkgData.exports[path] = {};
 				pkgData.exports[path].types = `./src/${item.name}/index.ts`;
 				if (item.native) pkgData.exports[path]["react-native"] = `./src/${item.name}/index.native.ts`;
@@ -1226,11 +1521,8 @@ 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("-", "/")}`)
-			];
+			const tsconfig = await readFile(join(root, "../../tsconfig.json"), "utf-8");
+			const external = Object.keys(JSON.parse(tsconfig).compilerOptions.paths);
 			await run.rm(this.dist);
 			const build = async (item) => {
 				const entries = [];
@@ -1243,7 +1535,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"),
@@ -1261,10 +1557,9 @@ var AlephaPackageBuilderCli = class {
 					dts: false,
 					external
 				});
-				const config = join(tmpDir, `tsdown-${item.name}.config.js`);
+				const config = join(tmpDir, `tsdown-${item.name.replace("/", "-")}.config.js`);
 				await this.fs.writeFile(config, `export default ${JSON.stringify(entries, null, 2)};`);
 				await run(`npx tsdown -c=${config}`);
-				await this.fs.rm(config);
 			};
 			const concurrency = Math.ceil(os.cpus().length / 2);
 			const queue = modules.slice();
@@ -1341,32 +1636,37 @@ function detectCircularDependencies(modules) {
 }
 async function analyzeModules(srcDir, packageName) {
 	const modules = [];
-	const entries = await readdir(srcDir, { withFileTypes: true });
-	for (const entry of entries) if (entry.isDirectory()) {
-		const moduleName = entry.name;
-		const modulePath = join(srcDir, moduleName);
-		const dependencies = /* @__PURE__ */ new Set();
-		const hasBrowser = await fileExists(join(modulePath, "index.browser.ts"));
-		const hasNative = await fileExists(join(modulePath, "index.native.ts"));
-		const hasNode = await fileExists(join(modulePath, "index.node.ts"));
-		const files = await getAllFiles(modulePath);
-		for (const file of files) {
-			const deps = extractAlephaDependencies(await readFile(file, "utf-8"), packageName, moduleName);
-			for (const dep of deps) {
-				if (dep.endsWith(".ts")) throw new Error(`Invalid dependency '${dep}' in module '${moduleName}'. Do not include file extensions in Alepha module imports.`);
-				if (dep.includes("-")) throw new Error(`Invalid dependency '${dep}' in module '${moduleName}'. Use '/' instead of '-' in Alepha module imports.`);
-				dependencies.add(dep);
-			}
+	async function scanDirectory(dir, prefix) {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) {
+			const moduleName = prefix ? `${prefix}/${entry.name}` : entry.name;
+			const modulePath = join(dir, entry.name);
+			if (await fileExists(join(modulePath, "index.ts"))) {
+				const dependencies = /* @__PURE__ */ new Set();
+				const hasBrowser = await fileExists(join(modulePath, "index.browser.ts"));
+				const hasNative = await fileExists(join(modulePath, "index.native.ts"));
+				const hasNode = await fileExists(join(modulePath, "index.node.ts"));
+				const files = await getAllFiles(modulePath);
+				for (const file of files) {
+					const deps = extractAlephaDependencies(await readFile(file, "utf-8"), packageName, moduleName);
+					for (const dep of deps) {
+						if (dep.endsWith(".ts")) throw new Error(`Invalid dependency '${dep}' in module '${moduleName}'. Do not include file extensions in Alepha module imports.`);
+						if (dep.includes("-")) throw new Error(`Invalid dependency '${dep}' in module '${moduleName}'. Use '/' instead of '-' in Alepha module imports.`);
+						dependencies.add(dep);
+					}
+				}
+				const module = {
+					name: moduleName,
+					dependencies: Array.from(dependencies)
+				};
+				if (hasNative) module.native = true;
+				if (hasBrowser) module.browser = true;
+				if (hasNode) module.node = true;
+				modules.push(module);
+			} else await scanDirectory(modulePath, moduleName);
 		}
-		const module = {
-			name: moduleName,
-			dependencies: Array.from(dependencies)
-		};
-		if (hasNative) module.native = true;
-		if (hasBrowser) module.browser = true;
-		if (hasNode) module.node = true;
-		modules.push(module);
 	}
+	await scanDirectory(srcDir, "");
 	detectCircularDependencies(modules);
 	return modules;
 }