alepha 0.14.3 → 0.14.4

package/dist/cli/index.js

@@ -1,17 +1,108 @@
-import { createRequire } from "node:module";
-import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, OPTIONS, t } from "alepha";
+import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, t } from "alepha";
 import { FileSystemProvider } from "alepha/file";
 import { access, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { $command, CliProvider, EnvUtils } from "alepha/command";
 import { $logger, ConsoleColorProvider } from "alepha/logger";
-import { boot, buildClient, buildServer, copyAssets, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
+import { boot, buildClient, buildServer, copyAssets, devServer, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
 import { exec, spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { promisify } from "node:util";
 import { ServerSwaggerProvider } from "alepha/server/swagger";
 import * as os from "node:os";
 
+//#region ../../src/core/constants/KIND.ts
+/**
+* Used for identifying primitives.
+*
+* @internal
+*/
+const KIND = Symbol.for("Alepha.Kind");
+
+//#endregion
+//#region ../../src/core/primitives/$atom.ts
+/**
+* Define an atom for state management.
+*
+* Atom lets you define a piece of state with a name, schema, and default value.
+*
+* By default, Alepha state is just a simple key-value store.
+* Using atoms allows you to have type safety, validation, and default values for your state.
+*
+* You control how state is structured and validated.
+*
+* Features:
+* - Set a schema for validation
+* - Set a default value for initial state
+* - Rules, like read-only, custom validation, etc.
+* - Automatic getter access in services with {@link $use}
+* - SSR support (server state automatically serialized and hydrated on client)
+* - React integration (useAtom hook for automatic component re-renders)
+* - Middleware
+* - Persistence adapters (localStorage, Redis, database, file system, cookie, etc.)
+* - State migrations (version upgrades when schema changes)
+* - Documentation generation & devtools integration
+*
+* Common use cases:
+* - user preferences
+* - feature flags
+* - configuration options
+* - session data
+*
+* Atom must contain only serializable data.
+* Avoid storing complex objects like class instances, functions, or DOM elements.
+* If you need to store complex data, consider using identifiers or references instead.
+*/
+const $atom$1 = (options) => {
+	return new Atom(options);
+};
+var Atom = class {
+	options;
+	get schema() {
+		return this.options.schema;
+	}
+	get key() {
+		return this.options.name;
+	}
+	constructor(options) {
+		this.options = options;
+	}
+};
+$atom$1[KIND] = "atom";
+
+//#endregion
+//#region ../../src/cli/atoms/buildOptions.ts
+/**
+* Build options atom for CLI build command.
+*
+* Defines the available build configuration options with their defaults.
+* Options can be overridden via vite.config.ts or CLI flags.
+*/
+const buildOptions = $atom$1({
+	name: "alepha.build.options",
+	description: "Build configuration options",
+	schema: t.object({
+		stats: t.optional(t.boolean({ default: false })),
+		vercel: t.optional(t.object({
+			projectName: t.optional(t.string()),
+			orgId: t.optional(t.string()),
+			projectId: t.optional(t.string()),
+			config: t.optional(t.object({ crons: t.optional(t.array(t.object({
+				path: t.string(),
+				schedule: t.string()
+			}))) }))
+		})),
+		cloudflare: t.optional(t.object({ config: t.optional(t.json()) })),
+		docker: t.optional(t.object({
+			image: t.optional(t.string({ default: "node:24-alpine" })),
+			command: t.optional(t.string({ default: "node" }))
+		})),
+		sitemap: t.optional(t.object({ hostname: t.string() }))
+	}),
+	default: {}
+});
+
+//#endregion
 //#region ../../src/cli/assets/appRouterTs.ts
 const appRouterTs = () => `
 import { $page } from "@alepha/react/router";
@@ -138,21 +229,6 @@ const tsconfigJson = `
 }
 `.trim();
 
-//#endregion
-//#region ../../src/cli/assets/viteConfigTs.ts
-const viteConfigTs = (serverEntry) => `
-import { viteAlepha } from "alepha/vite";
-
-export default {
-  plugins: [
-    viteAlepha(${serverEntry ? `{ serverEntry: "${serverEntry}" }` : ""}),
-  ],
-  test: {
-    globals: true,
-  },
-};
-`.trim();
-
 //#endregion
 //#region ../../src/cli/version.ts
 const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
@@ -236,6 +312,20 @@ var AlephaCliUtils = class {
 		this.log.debug(`Config file written: ${path}`);
 		return path;
 	}
+	async editFile(root, name, editFn) {
+		const filePath = join(root, name);
+		try {
+			await writeFile(filePath, await editFn(await readFile(filePath, "utf8")));
+		} catch (error) {
+			this.log.debug("Could not edit file", error);
+		}
+	}
+	async editJsonFile(root, name, editFn) {
+		return await this.editFile(root, name, async (content) => {
+			const newObj = await editFn(JSON.parse(content));
+			return JSON.stringify(newObj, null, 2);
+		});
+	}
 	async removeFiles(root, files) {
 		await Promise.all(files.map((file) => this.fs.rm(join(root, file), {
 			force: true,
@@ -246,17 +336,23 @@ var AlephaCliUtils = class {
 		await this.removeFiles(root, [
 			".yarn",
 			".yarnrc.yml",
-			".yarn"
+			"yarn.lock"
 		]);
+		await this.editJsonFile(root, "package.json", (pkg) => {
+			delete pkg.packageManager;
+		});
 	}
 	async removePnpm(root) {
 		await this.removeFiles(root, ["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
+		await this.editJsonFile(root, "package.json", (pkg) => {
+			delete pkg.packageManager;
+		});
 	}
 	async removeNpm(root) {
 		await this.removeFiles(root, ["package-lock.json"]);
 	}
 	async removeBun(root) {
-		await this.removeFiles(root, ["bun.lockb"]);
+		await this.removeFiles(root, ["bun.lockb", "bun.lock"]);
 	}
 	async removeAllPmFilesExcept(root, except) {
 		if (except !== "yarn") await this.removeYarn(root);
@@ -354,7 +450,6 @@ var AlephaCliUtils = class {
 		const tasks = [];
 		if (opts.packageJson) tasks.push(this.ensurePackageJson(root, typeof opts.packageJson === "boolean" ? {} : opts.packageJson));
 		if (opts.tsconfigJson) tasks.push(this.ensureTsConfig(root));
-		if (opts.viteConfigTs) tasks.push(this.ensureViteConfig(root));
 		if (opts.indexHtml) tasks.push(this.ensureIndexHtml(root));
 		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
 		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
@@ -370,14 +465,6 @@ var AlephaCliUtils = class {
 	async ensureTsConfig(root) {
 		await this.ensureFileExists(root, "tsconfig.json", tsconfigJson, true);
 	}
-	/**
-	* Ensure vite.config.ts exists in the project.
-	*
-	* Creates a standard Alepha vite.config.ts if none exists.
-	*/
-	async ensureViteConfig(root, serverEntry) {
-		await this.ensureFileExists(root, "vite.config.ts", viteConfigTs(serverEntry), false);
-	}
 	async checkFileExists(root, name, checkParentDirectories = false) {
 		const configPath = join(root, name);
 		if (!checkParentDirectories) try {
@@ -548,7 +635,7 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 		if ((await this.fs.ls(testDir)).length === 0) await this.fs.writeFile(dummyPath, dummySpecTs());
 	}
 	async readPackageJson(root) {
-		const packageJson$1 = await this.fs.createFile({ path: join(root, "package.json") }).text();
+		const packageJson$1 = await this.fs.createFile({ path: this.fs.join(root, "package.json") }).text();
 		return JSON.parse(packageJson$1);
 	}
 	/**
@@ -618,8 +705,10 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 var BuildCommand = class {
 	log = $logger();
 	utils = $inject(AlephaCliUtils);
+	options = $use(buildOptions);
 	build = $command({
 		name: "build",
+		mode: "production",
 		description: "Build the project for production",
 		args: t.optional(t.text({
 			title: "path",
@@ -636,33 +725,28 @@ var BuildCommand = class {
 			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
-			});
+			await this.utils.ensureConfig(root, { tsconfigJson: true });
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			const distDir = "dist";
 			const clientDir = "public";
 			await this.utils.ensureDependency(root, "vite", { run });
 			await run.rm("dist", { alias: "clean dist" });
-			const viteAlephaBuildOptions = (await createRequire(import.meta.url)("vite").resolveConfig({}, "build", "production")).plugins.find((it) => it.name === "alepha:build")?.[OPTIONS] || {};
+			const options = this.options;
 			await this.utils.loadEnv(root, [".env", ".env.production"]);
-			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
-			const hasServer = viteAlephaBuildOptions.serverEntry !== false;
+			const stats = flags.stats ?? options.stats ?? false;
 			let hasClient = false;
 			try {
 				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,
-					precompress: clientOptions.precompress
+					precompress: true
 				})
 			});
 			await run({
@@ -680,7 +764,7 @@ var BuildCommand = class {
 						clientDir: clientBuilt ? clientDir : void 0,
 						stats
 					});
-					if (clientBuilt && hasServer) await unlink(`${distDir}/${clientDir}/index.html`);
+					if (clientBuilt) await unlink(`${distDir}/${clientDir}/index.html`);
 				}
 			});
 			await copyAssets({
@@ -690,58 +774,49 @@ var BuildCommand = class {
 				run
 			});
 			if (hasClient) {
-				const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
-				if (sitemapBaseUrl) await run({
+				const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
+				if (sitemapHostname) await run({
 					name: "add sitemap",
 					handler: async () => {
 						await writeFile(`${distDir}/${clientDir}/sitemap.xml`, await generateSitemap({
 							entry: `${distDir}/index.js`,
-							baseUrl: sitemapBaseUrl
+							baseUrl: sitemapHostname
 						}));
 					}
 				});
-				if (clientOptions.prerender) await run({
+				await run({
 					name: "pre-render pages",
 					handler: async () => {
 						await prerenderPages({
 							dist: `${distDir}/${clientDir}`,
 							entry: `${distDir}/index.js`,
-							compress: clientOptions.precompress
+							compress: true
 						});
 					}
 				});
 			}
-			if (flags.vercel || viteAlephaBuildOptions.vercel) {
-				const config = typeof viteAlephaBuildOptions.vercel === "object" ? viteAlephaBuildOptions.vercel : {};
-				await run({
-					name: "add Vercel config",
-					handler: () => generateVercel({
-						distDir,
-						clientDir,
-						config
-					})
-				});
-			}
-			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({
-					name: "add Docker config",
-					handler: () => generateDocker({
-						distDir,
-						...dockerConfig
-					})
-				});
-			}
+			if (flags.vercel || options.vercel) await run({
+				name: "add Vercel config",
+				handler: () => generateVercel({
+					distDir,
+					clientDir,
+					config: options.vercel
+				})
+			});
+			if (flags.cloudflare || options.cloudflare) await run({
+				name: "add Cloudflare config",
+				handler: () => generateCloudflare({
+					distDir,
+					config: options.cloudflare?.config
+				})
+			});
+			if (flags.docker || options.docker) await run({
+				name: "add Docker config",
+				handler: () => generateDocker({
+					distDir,
+					...options.docker
+				})
+			});
 		}
 	});
 };
@@ -837,7 +912,6 @@ var DbCommand = class {
 	generate = $command({
 		name: "generate",
 		description: "Generate migration files based on current database schema",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -862,7 +936,6 @@ var DbCommand = class {
 	push = $command({
 		name: "push",
 		description: "Push database schema changes directly to the database",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -885,7 +958,6 @@ var DbCommand = class {
 	migrate = $command({
 		name: "migrate",
 		description: "Apply pending database migrations",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -908,7 +980,6 @@ var DbCommand = class {
 	studio = $command({
 		name: "studio",
 		description: "Launch Drizzle Studio database browser",
-		summary: false,
 		args: t.optional(t.text({
 			title: "path",
 			description: "Path to the Alepha server entry file"
@@ -1122,10 +1193,7 @@ var DevCommand = class {
 		})),
 		handler: async ({ args, root }) => {
 			const expo = await this.utils.hasExpo(root);
-			await this.utils.ensureConfig(root, {
-				viteConfigTs: !expo,
-				tsconfigJson: true
-			});
+			await this.utils.ensureConfig(root, { tsconfigJson: true });
 			if (expo) {
 				await this.utils.exec("expo start");
 				return;
@@ -1133,7 +1201,7 @@ var DevCommand = class {
 			const entry = await boot.getServerEntry(root, args);
 			this.log.trace("Entry file found", { entry });
 			if (!await this.isFullstackProject(root)) {
-				const exe = this.alepha.isBun() ? "bun" : "tsx";
+				const exe = await this.isBunProject(root) ? "bun" : "tsx";
 				let cmd = `${exe} --watch`;
 				if (await this.utils.exists(root, ".env")) cmd += " --env-file=./.env";
 				cmd += ` ${entry}`;
@@ -1141,9 +1209,18 @@ var DevCommand = class {
 				return;
 			}
 			await this.utils.ensureDependency(root, "vite");
-			await this.utils.exec("vite");
+			await devServer();
 		}
 	});
+	async isBunProject(root) {
+		if (this.alepha.isBun()) return true;
+		try {
+			await access(join(root, "bun.lock"));
+			return true;
+		} catch {
+			return false;
+		}
+	}
 	async isFullstackProject(root) {
 		try {
 			await access(join(root, "index.html"));
@@ -1385,6 +1462,39 @@ var ChangelogCommand = class {
 	});
 };
 
+//#endregion
+//#region ../../src/cli/commands/gen/env.ts
+var GenEnvCommand = class {
+	log = $logger();
+	utils = $inject(AlephaCliUtils);
+	fs = $inject(FileSystemProvider);
+	command = $command({
+		name: "env",
+		description: "Extract environment variables from server entry file",
+		flags: t.object({ out: t.optional(t.text({
+			aliases: ["o"],
+			description: "Output file path (e.g., .env)"
+		})) }),
+		handler: async ({ root, flags }) => {
+			const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+			try {
+				const { env } = alepha.dump();
+				let dotEnvFile = "";
+				for (const [key, value] of Object.entries(env)) {
+					if (value.description) dotEnvFile += `# ${value.description.split("\n").join("\n# ")}\n`;
+					if (value.required && !value.default) dotEnvFile += `# (required)\n`;
+					if (value.enum) dotEnvFile += `# Possible values: ${value.enum.join(", ")}\n`;
+					dotEnvFile += `${key}=${value.default || ""}\n\n`;
+				}
+				if (flags.out) await this.fs.writeFile(this.fs.join(root, flags.out), dotEnvFile);
+				else this.log.info(dotEnvFile);
+			} catch (err) {
+				this.log.error("Failed to extract environment variables", err);
+			}
+		}
+	});
+};
+
 //#endregion
 //#region ../../src/cli/commands/gen/openapi.ts
 var OpenApiCommand = class {
@@ -1420,7 +1530,7 @@ var OpenApiCommand = class {
 					this.log.error("Missing $swagger() primitive in your server configuration.");
 					return;
 				}
-				this.log.error(`OpenAPI generation failed - ${message}`, { err });
+				this.log.error(`OpenAPI generation failed - ${message}`, err);
 			}
 		}
 	});
@@ -1431,10 +1541,15 @@ var OpenApiCommand = class {
 var GenCommand = class {
 	changelog = $inject(ChangelogCommand);
 	openapi = $inject(OpenApiCommand);
+	genEnv = $inject(GenEnvCommand);
 	gen = $command({
 		name: "gen",
 		description: "Generate code, documentation, ...",
-		children: [this.changelog.command, this.openapi.command],
+		children: [
+			this.changelog.command,
+			this.openapi.command,
+			this.genEnv.command
+		],
 		handler: async ({ help }) => {
 			help();
 		}
@@ -1471,7 +1586,6 @@ var InitCommand = class {
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
-						viteConfigTs: !isExpo,
 						editorconfig: true,
 						indexHtml: !!flags.react && !isExpo
 					});
@@ -1539,30 +1653,6 @@ var RootCommand = class {
 	});
 };
 
-//#endregion
-//#region ../../src/cli/commands/run.ts
-var RunCommand = class {
-	utils = $inject(AlephaCliUtils);
-	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",
-			alias: "w"
-		})) }),
-		summary: false,
-		args: t.text({
-			title: "path",
-			description: "Filepath to run"
-		}),
-		handler: async ({ args, flags, root }) => {
-			await this.utils.ensureTsConfig(root);
-			await this.utils.exec(`tsx ${flags.watch ? "watch " : ""}${args}`);
-		}
-	});
-};
-
 //#endregion
 //#region ../../src/cli/commands/test.ts
 var TestCommand = class {
@@ -1579,10 +1669,7 @@ var TestCommand = class {
 			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.ensureConfig(root, { tsconfigJson: true });
 			await this.utils.ensureDependency(root, "vitest");
 			const config = flags.config ? `--config=${flags.config}` : "";
 			await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
@@ -1637,7 +1724,7 @@ var VerifyCommand = class {
 			await run("alepha lint");
 			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");
+			if (await this.utils.exists(root, "migrations")) await run("alepha db check-migrations");
 			if (!await this.utils.hasExpo(root)) await run("alepha build");
 			await run("alepha clean");
 		}
@@ -1686,7 +1773,6 @@ const AlephaCli = $module({
 		InitCommand,
 		LintCommand,
 		RootCommand,
-		RunCommand,
 		TestCommand,
 		TypecheckCommand,
 		VerifyCommand,
@@ -1890,11 +1976,13 @@ async function analyzeModules(srcDir, packageName) {
 
 //#endregion
 //#region ../../src/cli/defineConfig.ts
-const defineConfig = (config) => {
+const defineConfig = (runConfig) => {
 	return (alepha) => {
-		const { commands, services = [] } = config(alepha);
-		for (const it of services) alepha.with(it);
-		return { ...commands };
+		const config = typeof runConfig === "function" ? runConfig(alepha) : runConfig;
+		if (config.services) for (const it of config.services) alepha.with(it);
+		if (config.env) for (const [key, value] of Object.entries(config.env)) process.env[key] = String(value);
+		if (config.build) alepha.set(buildOptions, config.build);
+		return { ...config.commands };
 	};
 };
 /**
@@ -1903,5 +1991,5 @@ const defineConfig = (config) => {
 const defineAlephaConfig = defineConfig;
 
 //#endregion
-export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, RunCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
+export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
 //# sourceMappingURL=index.js.map