alepha 0.13.6 → 0.13.8

package/dist/cli/index.js

@@ -36,7 +36,7 @@ const biomeJson = `
   },
   "formatter": {
     "enabled": true,
-    "indentStyle": "space"
+    "useEditorconfig": true
   },
   "linter": {
     "enabled": true,
@@ -57,6 +57,32 @@ const biomeJson = `
 }
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/dummySpecTs.ts
+const dummySpecTs = () => `
+import { test, expect } from "vitest";
+
+test("dummy test", () => {
+  expect(1 + 1).toBe(2);
+});
+`.trim();
+
+//#endregion
+//#region ../../src/cli/assets/editorconfig.ts
+const editorconfig = `
+# https://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+`.trim();
+
 //#endregion
 //#region ../../src/cli/assets/indexHtml.ts
 const indexHtml = (browserEntry) => `
@@ -86,6 +112,23 @@ alepha.with(AppRouter);
 run(alepha);
 `.trim();
 
+//#endregion
+//#region ../../src/cli/assets/mainTs.ts
+const mainTs = () => `
+import { Alepha, run } from "alepha";
+import { $logger } from "alepha/logger";
+
+const alepha = Alepha.create();
+
+alepha.with(() => {
+  const log = $logger();
+
+  log.info("Hello from Alepha!");
+});
+
+run(alepha);
+`.trim();
+
 //#endregion
 //#region ../../src/cli/assets/tsconfigJson.ts
 const tsconfigJson = `
@@ -132,34 +175,39 @@ var AlephaCliUtils = class {
 	/**
 	* Execute a command using npx with inherited stdio.
 	*
-	* @param command - The command to execute (will be passed to npx)
-	* @param env - Optional environment variables to set for the command
-	* @returns Promise that resolves when the process exits
-	*
 	* @example
 	* ```ts
 	* const runner = alepha.inject(ProcessRunner);
 	* await runner.exec("tsx watch src/index.ts");
 	* ```
 	*/
-	async exec(command, env = {}) {
+	async exec(command, options = {}) {
 		const root = process.cwd();
 		this.log.debug(`Executing command: ${command}`, { cwd: root });
+		const runExec = async (app$1, args$1) => {
+			const prog = spawn(app$1, args$1, {
+				stdio: "inherit",
+				cwd: root,
+				env: {
+					...process.env,
+					...options.env
+				}
+			});
+			await new Promise((resolve) => prog.on("exit", () => {
+				resolve();
+			}));
+		};
+		if (options.global) {
+			const [app$1, ...args$1] = command.split(" ");
+			await runExec(app$1, args$1);
+			return;
+		}
 		const suffix = process.platform === "win32" ? ".cmd" : "";
 		const [app, ...args] = command.split(" ");
-		const execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`, true);
+		let execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`, true);
+		if (!execPath) execPath = await this.checkFileExists(root, `node_modules/alepha/node_modules/.bin/${app}${suffix}`, true);
 		if (!execPath) throw new AlephaError(`Could not find executable for command '${app}'. Make sure the package is installed.`);
-		const prog = spawn(execPath, args, {
-			stdio: "inherit",
-			cwd: root,
-			env: {
-				...process.env,
-				...env
-			}
-		});
-		await new Promise((resolve) => prog.on("exit", () => {
-			resolve();
-		}));
+		await runExec(execPath, args);
 	}
 	/**
 	* Write a configuration file to node_modules/.alepha directory.
@@ -197,6 +245,24 @@ var AlephaCliUtils = class {
 		await this.fs.rm(join(root, "package-lock.json"), { force: true });
 		await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
 	}
+	async ensurePnpm(root) {
+		await this.fs.rm(join(root, "package-lock.json"), { force: true });
+		await this.fs.rm(join(root, "yarn.lock"), { force: true });
+		await this.fs.rm(join(root, ".yarn"), {
+			force: true,
+			recursive: true
+		});
+		await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+	}
+	async ensureNpm(root) {
+		await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
+		await this.fs.rm(join(root, "yarn.lock"), { force: true });
+		await this.fs.rm(join(root, ".yarn"), {
+			force: true,
+			recursive: true
+		});
+		await this.fs.rm(join(root, ".yarnrc.yml"), { force: true });
+	}
 	/**
 	* Generate package.json content with Alepha dependencies.
 	*
@@ -206,6 +272,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;
@@ -220,11 +293,7 @@ var AlephaCliUtils = class {
 			type: "module",
 			dependencies,
 			devDependencies,
-			scripts: {
-				dev: "alepha dev",
-				build: "alepha build",
-				verify: "alepha verify"
-			}
+			scripts
 		};
 	}
 	/**
@@ -243,8 +312,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);
@@ -257,6 +327,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 = [];
@@ -265,7 +336,8 @@ var AlephaCliUtils = class {
 		if (opts.viteConfigTs) tasks.push(this.ensureViteConfig(root));
 		if (opts.indexHtml) tasks.push(this.ensureIndexHtml(root));
 		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
-		await Promise.all(tasks);
+		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
+		return await Promise.all(tasks);
 	}
 	/**
 	* Ensure tsconfig.json exists in the project.
@@ -321,6 +393,16 @@ var AlephaCliUtils = class {
 		await this.ensureFileExists(root, "biome.json", biomeJson, true);
 	}
 	/**
+	* Ensure .editorconfig exists in the project.
+	*
+	* Creates a standard .editorconfig if none exists.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureEditorConfig(root) {
+		await this.ensureFileExists(root, ".editorconfig", editorconfig, true);
+	}
+	/**
 	* Load Alepha instance from a server entry file.
 	*
 	* Dynamically imports the server entry file and extracts the Alepha instance.
@@ -454,10 +536,14 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 				rootDir
 			});
 			const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
-			await this.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { NODE_OPTIONS: "--import tsx" });
+			await this.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { env: { NODE_OPTIONS: "--import tsx" } });
 		}
 	}
-	async getPackageManager(root) {
+	async getPackageManager(root, flags) {
+		if (flags?.yarn) return "yarn";
+		if (flags?.pnpm) return "pnpm";
+		if (flags?.npm) return "npm";
+		if (flags?.bun) return "bun";
 		if (await this.checkFileExists(root, "yarn.lock", true)) return "yarn";
 		if (await this.checkFileExists(root, "pnpm-lock.yaml", true)) return "pnpm";
 		return "npm";
@@ -478,10 +564,100 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 	async exists(root, dirName) {
 		return this.fs.exists(join(root, dirName));
 	}
+	/**
+	* Ensure src/main.ts exists with a minimal Alepha bootstrap.
+	*
+	* Creates the src directory and main.ts file if the src directory
+	* doesn't exist or is empty.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureSrcMain(root) {
+		const srcDir = join(root, "src");
+		const mainPath = join(srcDir, "main.ts");
+		if (!await this.fs.exists(srcDir)) {
+			await this.fs.mkdir(srcDir, { recursive: true });
+			await this.fs.writeFile(mainPath, mainTs());
+			return;
+		}
+		if ((await this.fs.ls(srcDir)).length === 0) await this.fs.writeFile(mainPath, mainTs());
+	}
+	/**
+	* Ensure test directory exists with a dummy test file.
+	*
+	* Creates the test directory and a dummy.spec.ts file if the test directory
+	* doesn't exist or is empty.
+	*
+	* @param root - The root directory of the project
+	*/
+	async ensureTestDir(root) {
+		const testDir = join(root, "test");
+		const dummyPath = join(testDir, "dummy.spec.ts");
+		if (!await this.fs.exists(testDir)) {
+			await this.fs.mkdir(testDir, { recursive: true });
+			await this.fs.writeFile(dummyPath, dummySpecTs());
+			return;
+		}
+		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();
 		return JSON.parse(packageJson$1);
 	}
+	/**
+	* Check if a dependency is installed in the project.
+	*
+	* @param root - The root directory of the project
+	* @param packageName - The name of the package to check
+	* @returns True if the package is in dependencies or devDependencies
+	*/
+	async hasDependency(root, packageName) {
+		try {
+			const pkg = await this.readPackageJson(root);
+			return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName]);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* 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
+	* the package as a dev dependency if not already present.
+	*/
+	async ensureDependency(root, packageName, options = {}) {
+		const { dev = true } = options;
+		if (await this.hasDependency(root, packageName)) {
+			this.log.debug(`Dependency '${packageName}' is already installed`);
+			return;
+		}
+		const pm = await this.getPackageManager(root);
+		let cmd;
+		switch (pm) {
+			case "yarn":
+				cmd = `yarn add ${dev ? "-D" : ""} ${packageName}`;
+				break;
+			case "pnpm":
+				cmd = `pnpm add ${dev ? "-D" : ""} ${packageName}`;
+				break;
+			default: cmd = `npm install ${dev ? "--save-dev" : ""} ${packageName}`;
+		}
+		cmd = cmd.replace(/\s+/g, " ").trim();
+		if (options.run) await options.run(cmd, { alias: `installing ${packageName}` });
+		else {
+			this.log.debug(`Installing ${packageName}`);
+			await this.exec(cmd, { global: true });
+		}
+	}
 };
 
 //#endregion
@@ -494,6 +670,7 @@ var BiomeCommands = class {
 		description: "Format the codebase using Biome",
 		handler: async ({ root }) => {
 			await this.utils.ensureConfig(root, { biomeJson: true });
+			await this.utils.ensureDependency(root, "@biomejs/biome");
 			await this.utils.exec(`biome format --fix`);
 		}
 	});
@@ -502,6 +679,7 @@ var BiomeCommands = class {
 		description: "Run linter across the codebase using Biome",
 		handler: async ({ root }) => {
 			await this.utils.ensureConfig(root, { biomeJson: true });
+			await this.utils.ensureDependency(root, "@biomejs/biome");
 			await this.utils.exec(`biome check --formatter-enabled=false --fix`);
 		}
 	});
@@ -550,29 +728,42 @@ var CoreCommands = class {
 		flags: t.object({
 			yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
 			pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
+			npm: t.optional(t.boolean({ description: "Use npm package manager" })),
+			bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
 			react: t.optional(t.boolean({ description: "Include Alepha React dependencies" })),
-			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" }))
+			ui: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
+			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" }))
 		}),
 		handler: async ({ run, flags, root }) => {
 			if (flags.ui) flags.react = true;
+			const isExpo = await this.utils.hasExpo(root);
 			await run({
-				name: "Ensuring configuration files",
+				name: "ensuring configuration files",
 				handler: async () => {
 					await this.utils.ensureConfig(root, {
 						tsconfigJson: true,
 						packageJson: flags,
 						biomeJson: true,
-						viteConfigTs: true,
-						indexHtml: !!flags.react
+						viteConfigTs: !isExpo,
+						editorconfig: true,
+						indexHtml: !!flags.react && !isExpo
 					});
+					if (!flags.react) await this.utils.ensureSrcMain(root);
 				}
 			});
-			const guessedPm = await this.utils.getPackageManager(root);
-			if (flags.yarn || guessedPm === "yarn") {
+			const pm = await this.utils.getPackageManager(root, flags);
+			if (pm === "yarn") {
 				await this.utils.ensureYarn(root);
 				await run("yarn set version stable");
-				await run("yarn install", { alias: "Installing dependencies with Yarn" });
-			} else await run("npm install", { alias: "Installing dependencies with npm" });
+			} 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" });
+			}
 		}
 	});
 };
@@ -784,7 +975,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");
 		}
 	});
@@ -794,7 +985,8 @@ var VerifyCommands = class {
 	typecheck = $command({
 		name: "typecheck",
 		description: "Check TypeScript types across the codebase",
-		handler: async () => {
+		handler: async ({ root }) => {
+			await this.utils.ensureDependency(root, "typescript");
 			await this.utils.exec("tsc --noEmit");
 		}
 	});
@@ -808,6 +1000,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",
@@ -837,10 +1030,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 {
@@ -853,6 +1051,7 @@ var ViteCommands = class {
 				await this.utils.exec(cmd);
 				return;
 			}
+			await this.utils.ensureDependency(root, "vite");
 			await this.utils.exec(`vite`);
 		}
 	});
@@ -873,6 +1072,7 @@ var ViteCommands = class {
 		}),
 		handler: async ({ flags, args, run, root }) => {
 			process.env.ALEPHA_BUILD_MODE = "cli";
+			if (await this.utils.hasExpo(root)) return;
 			await this.utils.ensureConfig(root, {
 				viteConfigTs: true,
 				tsconfigJson: true
@@ -881,6 +1081,7 @@ var ViteCommands = class {
 			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 import(join(root, "vite.config.ts")))?.default?.plugins.find((it) => !!it[OPTIONS])?.[OPTIONS] ?? {};
 			const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
@@ -916,12 +1117,11 @@ 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);
@@ -979,12 +1179,7 @@ var ViteCommands = class {
 				tsconfigJson: true,
 				viteConfigTs: true
 			});
-			try {
-				await import("./dist-BlfFtOk2.js");
-			} catch {
-				this.log.error("Vitest is not installed. Please install it with `npm install -D vitest` or `yarn add -D vitest`.");
-				process.exit(1);
-			}
+			await this.utils.ensureDependency(root, "vitest");
 			await this.utils.exec(`vitest run ${this.env.VITEST_ARGS}`);
 		}
 	});
@@ -1036,7 +1231,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`;
@@ -1057,7 +1254,7 @@ var AlephaPackageBuilderCli = class {
 			const external = [
 				"alepha",
 				packageName,
-				...modules.map((item) => `${packageName}/${item.name.replace("-", "/")}`)
+				...modules.map((item) => `${packageName}/${item.name.replace("-", "/").replace("/core", "")}`)
 			];
 			await run.rm(this.dist);
 			const build = async (item) => {
@@ -1089,10 +1286,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();
@@ -1169,32 +1365,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;
 }