buncargo 1.0.26 → 3.0.0

package/dist/index-wk2na3t9.js

@@ -0,0 +1,404 @@
+// environment.ts
+import pc from "picocolors";
+import {
+	buildApps,
+	execAsync,
+	startDevServers,
+	stopProcess,
+} from "./index-1yvbwj4k.js";
+import {
+	getLocalIp,
+	isCI,
+	logExpoApiUrl,
+	logFrontendPort,
+	waitForDevServers,
+	waitForServer,
+} from "./index-8xj2p5n5.js";
+import {
+	computeDevIdentity,
+	computePorts,
+	computeUrls,
+	findMonorepoRoot,
+} from "./index-731rzzfp.js";
+import {
+	spawnWatchdog,
+	startHeartbeat,
+	stopHeartbeat,
+	stopWatchdog,
+} from "./index-ggq3yryx.js";
+import { createPrismaRunner } from "./index-qfphr2fd.js";
+import { assertValidConfig } from "./index-tjqw9vtj.js";
+import {
+	areContainersRunning,
+	startContainers,
+	stopContainers,
+} from "./index-zfjzzjkf.js";
+
+function formatUrl(url) {
+	return pc.cyan(
+		url.replace(/:(\d+)(\/?)/, (_, port, slash) => `:${pc.bold(port)}${slash}`),
+	);
+}
+function formatLabel(label, value, arrow = "➜") {
+	return `  ${pc.green(arrow)}  ${pc.bold(label.padEnd(10))} ${value}`;
+}
+function formatDimLabel(label, value) {
+	return `  ${pc.dim("•")}  ${pc.dim(label.padEnd(10))} ${pc.dim(value)}`;
+}
+function createDevEnvironment(config, options = {}) {
+	assertValidConfig(config);
+	const root = findMonorepoRoot();
+	const suffix = options.suffix;
+	const identity = computeDevIdentity({
+		projectPrefix: config.projectPrefix,
+		suffix,
+		root,
+		worktreeIsolation: config.options?.worktreeIsolation,
+	});
+	const { worktree, projectSuffix, portOffset, projectName } = identity;
+	const localIp = getLocalIp();
+	const services = config.services;
+	const apps = config.apps ?? {};
+	const ports = computePorts(services, apps, portOffset);
+	const urls = computeUrls(services, apps, ports, localIp);
+	function buildEnvVars(production = false) {
+		const baseEnv = {
+			COMPOSE_PROJECT_NAME: projectName,
+			NODE_ENV: production ? "production" : "development",
+		};
+		for (const [name, port] of Object.entries(ports)) {
+			const envName = `${name.toUpperCase()}_PORT`;
+			baseEnv[envName] = String(port);
+		}
+		for (const [name, url] of Object.entries(urls)) {
+			const envName = `${name.toUpperCase()}_URL`;
+			baseEnv[envName] = url;
+		}
+		if (config.envVars) {
+			const userEnv = config.envVars(ports, urls, {
+				projectName,
+				localIp,
+				portOffset,
+			});
+			for (const [key, value] of Object.entries(userEnv)) {
+				baseEnv[key] = String(value);
+			}
+		}
+		return baseEnv;
+	}
+	let hookContext = null;
+	function getHookContext() {
+		if (!hookContext) {
+			hookContext = {
+				projectName,
+				ports,
+				urls,
+				root,
+				isCI: isCI(),
+				portOffset,
+				localIp,
+				exec: async (cmd, opts) => {
+					const envVars = buildEnvVars();
+					return execAsync(cmd, root, envVars, opts);
+				},
+			};
+		}
+		return hookContext;
+	}
+	function exec(cmd, options2) {
+		const envVars = buildEnvVars();
+		return execAsync(cmd, root, envVars, options2);
+	}
+	async function start(startOptions = {}) {
+		const isCI2 = process.env.CI === "true";
+		const {
+			verbose = config.options?.verbose ?? true,
+			wait = true,
+			startServers: shouldStartServers = true,
+			productionBuild = isCI2,
+			skipSeed = false,
+		} = startOptions;
+		const envVars = buildEnvVars(productionBuild);
+		if (verbose) {
+			logInfo(productionBuild ? "Production Environment" : "Dev Environment");
+		}
+		const serviceCount = Object.keys(services).length;
+		const alreadyRunning = await areContainersRunning(
+			projectName,
+			serviceCount,
+		);
+		if (alreadyRunning) {
+			if (verbose) console.log("✓ Containers already running");
+		} else {
+			startContainers(root, projectName, envVars, {
+				verbose,
+				wait,
+				composeFile: config.options?.composeFile,
+			});
+		}
+		const allMigrations = [
+			...(config.prisma
+				? [
+						{
+							name: "prisma",
+							command: "bunx prisma migrate deploy",
+							cwd: config.prisma.cwd ?? "packages/prisma",
+						},
+					]
+				: []),
+			...(config.migrations ?? []),
+		];
+		if (allMigrations.length > 0) {
+			if (verbose) console.log("\uD83D\uDCE6 Running migrations...");
+			const migrationResults = await Promise.all(
+				allMigrations.map(async (migration) => {
+					const result = await exec(migration.command, {
+						cwd: migration.cwd,
+						throwOnError: false,
+					});
+					return { name: migration.name, result };
+				}),
+			);
+			for (const { name, result } of migrationResults) {
+				if (result.exitCode !== 0) {
+					console.error(`❌ Migration "${name}" failed`);
+					if (result.stdout) {
+						console.error(result.stdout);
+					}
+					if (result.stderr) {
+						console.error(result.stderr);
+					}
+					throw new Error(`Migration "${name}" failed`);
+				}
+			}
+			if (verbose) console.log("✓ Migrations complete");
+		}
+		if (config.hooks?.afterContainersReady) {
+			await config.hooks.afterContainersReady(getHookContext());
+		}
+		if (config.seed && !skipSeed) {
+			let shouldSeed = true;
+			if (config.seed.check) {
+				const checkTable = async (tableName, service) => {
+					const serviceName = service ?? "postgres";
+					const serviceUrl = urls[serviceName];
+					if (!serviceUrl) {
+						console.warn(`⚠️ Service "${serviceName}" not found for checkTable`);
+						return true;
+					}
+					const checkResult = await exec(
+						`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`,
+						{ throwOnError: false },
+					);
+					const count = checkResult.stdout.trim();
+					const shouldSeed2 =
+						checkResult.exitCode !== 0 || count === "0" || count === "";
+					if (!shouldSeed2) {
+						console.log(
+							`  \uD83D\uDCCA Table "${tableName}" has ${count} rows`,
+						);
+					}
+					return shouldSeed2;
+				};
+				const seedCheckContext = {
+					...getHookContext(),
+					checkTable,
+				};
+				shouldSeed = await config.seed.check(seedCheckContext);
+			}
+			if (shouldSeed) {
+				if (verbose) console.log("\uD83C\uDF31 Running seeders...");
+				const seedResult = await exec(config.seed.command, {
+					cwd: config.seed.cwd,
+					verbose,
+					throwOnError: false,
+				});
+				if (seedResult.exitCode !== 0) {
+					console.error("❌ Seeding failed");
+					console.error(seedResult.stderr);
+				} else {
+					if (verbose) console.log("✓ Seeding complete");
+				}
+			} else {
+				if (verbose)
+					console.log("✓ Database already has data, skipping seeders");
+			}
+		}
+		if (shouldStartServers && Object.keys(apps).length > 0) {
+			if (config.hooks?.beforeServers) {
+				await config.hooks.beforeServers(getHookContext());
+			}
+			if (productionBuild) {
+				buildApps(apps, root, envVars, { verbose });
+			}
+			const pids = await startDevServers(apps, root, envVars, ports, {
+				verbose,
+				productionBuild,
+				isCI: isCI2,
+			});
+			if (verbose) console.log("⏳ Waiting for servers to be ready...");
+			await waitForDevServers(apps, ports, {
+				timeout: isCI2 ? 120000 : 60000,
+				verbose,
+				productionBuild,
+			});
+			if (config.hooks?.afterServers) {
+				await config.hooks.afterServers(getHookContext());
+			}
+			if (verbose)
+				console.log(`✅ Environment ready
+`);
+			return pids;
+		}
+		if (verbose)
+			console.log(`✅ Containers ready
+`);
+		return null;
+	}
+	async function stop(stopOptions = {}) {
+		const { verbose = true, removeVolumes = false } = stopOptions;
+		if (config.hooks?.beforeStop) {
+			await config.hooks.beforeStop(getHookContext());
+		}
+		stopContainers(root, projectName, {
+			verbose,
+			removeVolumes,
+			composeFile: config.options?.composeFile,
+		});
+	}
+	async function restart() {
+		await stop();
+		await start({ startServers: false });
+	}
+	async function isRunning() {
+		const serviceCount = Object.keys(services).length;
+		return areContainersRunning(projectName, serviceCount);
+	}
+	async function startServersOnly(options2 = {}) {
+		const { productionBuild = false, verbose = true } = options2;
+		const envVars = buildEnvVars(productionBuild);
+		const isCI2 = process.env.CI === "true";
+		if (productionBuild) {
+			buildApps(apps, root, envVars, { verbose });
+		}
+		return startDevServers(apps, root, envVars, ports, {
+			verbose,
+			productionBuild,
+			isCI: isCI2,
+		});
+	}
+	async function waitForServersReady(options2 = {}) {
+		const { timeout = 60000, productionBuild = false } = options2;
+		await waitForDevServers(apps, ports, { timeout, productionBuild });
+	}
+	function logInfo(label = "Docker Dev") {
+		const serviceNames = Object.keys(services);
+		const appNames = Object.keys(apps);
+		console.log("");
+		console.log(`  ${pc.cyan(pc.bold(`\uD83D\uDC33 ${label}`))}`);
+		console.log(formatLabel("Project:", pc.white(projectName)));
+		if (serviceNames.length > 0) {
+			console.log("");
+			console.log(`  ${pc.dim("─── Services ───")}`);
+			for (const name of serviceNames) {
+				const port = ports[name];
+				const url = `localhost:${port}`;
+				console.log(formatLabel(`${name}:`, formatUrl(`http://${url}`)));
+			}
+		}
+		if (appNames.length > 0) {
+			console.log("");
+			console.log(`  ${pc.dim("─── Applications ───")}`);
+			for (const name of appNames) {
+				const port = ports[name];
+				const localUrl = `http://localhost:${port}`;
+				const networkUrl = `http://${localIp}:${port}`;
+				console.log(`  ${pc.green("➜")}  ${pc.bold(pc.cyan(name))}`);
+				console.log(`       ${pc.dim("Local:")}   ${formatUrl(localUrl)}`);
+				console.log(`       ${pc.dim("Network:")} ${formatUrl(networkUrl)}`);
+			}
+		}
+		console.log("");
+		console.log(`  ${pc.dim("─── Environment ───")}`);
+		console.log(formatDimLabel("Worktree:", worktree ? "yes" : "no"));
+		console.log(
+			formatDimLabel(
+				"Port offset:",
+				portOffset > 0 ? `+${portOffset}` : "none",
+			),
+		);
+		if (projectSuffix) {
+			console.log(formatDimLabel("Suffix:", projectSuffix));
+		}
+		console.log(formatDimLabel("Local IP:", localIp));
+		console.log("");
+	}
+	async function waitForServerUrl(url, timeout) {
+		await waitForServer(url, { timeout });
+	}
+	function startHeartbeat2(intervalMs) {
+		startHeartbeat(projectName, intervalMs);
+	}
+	function stopHeartbeat2() {
+		stopHeartbeat();
+	}
+	async function spawnWatchdog2(timeoutMinutes) {
+		await spawnWatchdog(projectName, root, {
+			timeoutMinutes,
+			verbose: true,
+			composeFile: config.options?.composeFile,
+		});
+	}
+	function stopWatchdog2() {
+		stopWatchdog(projectName);
+	}
+	function getExpoApiUrl() {
+		const apiPort = ports.api;
+		const url = `http://${localIp}:${apiPort}`;
+		logExpoApiUrl(url);
+		return url;
+	}
+	function getFrontendPort() {
+		const port = ports.platform;
+		logFrontendPort(port);
+		return port;
+	}
+	function withSuffix(newSuffix) {
+		return createDevEnvironment(config, { suffix: newSuffix });
+	}
+	const env = {
+		projectName,
+		ports,
+		urls,
+		apps,
+		portOffset,
+		isWorktree: worktree,
+		localIp,
+		root,
+		start,
+		stop,
+		restart,
+		isRunning,
+		startServers: startServersOnly,
+		stopProcess,
+		waitForServers: waitForServersReady,
+		buildEnvVars,
+		exec,
+		waitForServer: waitForServerUrl,
+		logInfo,
+		getExpoApiUrl,
+		getFrontendPort,
+		startHeartbeat: startHeartbeat2,
+		stopHeartbeat: stopHeartbeat2,
+		spawnWatchdog: spawnWatchdog2,
+		stopWatchdog: stopWatchdog2,
+		prisma: undefined,
+		withSuffix,
+	};
+	if (config.prisma) {
+		env.prisma = createPrismaRunner(env, config.prisma);
+	}
+	return env;
+}
+
+export { createDevEnvironment };