buncargo 1.0.29 → 3.0.0

package/src/docker-compose/services/index.ts

@@ -0,0 +1,67 @@
+import type {
+	DockerComposeServiceRaw,
+	DockerPresetName,
+	ServiceConfig,
+} from "../../types";
+import type { DockerServicePreset } from "./define-docker-service";
+
+export type {
+	DockerServicePreset,
+	DockerServicePresetDefaults,
+	PresetServiceSharedOptions,
+} from "./define-docker-service";
+
+import {
+	type ClickhouseServiceOptions,
+	clickhouseDockerService,
+} from "./clickhouse";
+import { type PostgresServiceOptions, postgresDockerService } from "./postgres";
+import { type RedisServiceOptions, redisDockerService } from "./redis";
+
+const PRESET_SERVICES = {
+	postgres: postgresDockerService,
+	redis: redisDockerService,
+	clickhouse: clickhouseDockerService,
+} satisfies Record<DockerPresetName, DockerServicePreset>;
+
+export { clickhouseDockerService, postgresDockerService, redisDockerService };
+export type {
+	ClickhouseServiceOptions,
+	PostgresServiceOptions,
+	RedisServiceOptions,
+};
+
+export type CustomServiceOptions = ServiceConfig & {
+	docker: DockerComposeServiceRaw;
+};
+
+/**
+ * Public service builders for dev.config.ts.
+ * Core owns this surface so defaults and preset mapping live in one place.
+ */
+export const service = {
+	postgres: postgresDockerService.toServiceConfig,
+	redis: redisDockerService.toServiceConfig,
+	clickhouse: clickhouseDockerService.toServiceConfig,
+
+	custom(options: CustomServiceOptions): ServiceConfig {
+		return options;
+	},
+};
+
+export function inferDockerPreset(
+	serviceKey: string,
+): DockerPresetName | undefined {
+	const normalized = serviceKey.toLowerCase();
+	if (Object.hasOwn(PRESET_SERVICES, normalized)) {
+		return normalized as DockerPresetName;
+	}
+	return undefined;
+}
+
+export function buildPresetDockerService(
+	preset: DockerPresetName,
+	input: Parameters<DockerServicePreset["build"]>[0],
+): ReturnType<DockerServicePreset["build"]> {
+	return PRESET_SERVICES[preset].build(input);
+}

package/src/docker-compose/services/postgres.ts

@@ -0,0 +1,60 @@
+import type {
+	BuiltInHealthCheck,
+	DockerComposeHealthcheckRaw,
+	DockerComposeServiceRaw,
+} from "../../types";
+import { defineDockerService } from "./define-docker-service";
+import { getDefaultPortBindings, resolveHealthcheck } from "./shared";
+
+export type PostgresServiceOptions = {
+	port?: number;
+	expose?: boolean;
+	healthCheck?: BuiltInHealthCheck | false;
+	serviceName?: string;
+	database?: string;
+	user?: string;
+	password?: string;
+	docker?: DockerComposeServiceRaw;
+};
+
+export const postgresDockerService =
+	defineDockerService<PostgresServiceOptions>({
+		preset: "postgres",
+		defaults: {
+			port: 5432,
+			healthCheck: "pg_isready",
+		},
+		build: ({ serviceKey, config }) => {
+			const user = config.user ?? "postgres";
+			const password = config.password ?? "postgres";
+			const database = config.database ?? "postgres";
+			const defaultHealthcheck: DockerComposeHealthcheckRaw = {
+				test: ["CMD-SHELL", `pg_isready -U ${user}`],
+				interval: "250ms",
+				timeout: "5s",
+				retries: 20,
+			};
+
+			return {
+				service: {
+					image: "pgvector/pgvector:pg16",
+					ports: getDefaultPortBindings(serviceKey, config, "postgres"),
+					volumes: [`${serviceKey}_data:/var/lib/postgresql/data`],
+					environment: {
+						POSTGRES_USER: user,
+						POSTGRES_PASSWORD: password,
+						POSTGRES_DB: database,
+					},
+					healthcheck: resolveHealthcheck(
+						config.healthCheck,
+						defaultHealthcheck,
+						{
+							internalPort: 5432,
+							user,
+						},
+					),
+				},
+				volume: `${serviceKey}_data`,
+			};
+		},
+	});

package/src/docker-compose/services/redis.ts

@@ -0,0 +1,48 @@
+import type {
+	BuiltInHealthCheck,
+	DockerComposeHealthcheckRaw,
+	DockerComposeServiceRaw,
+} from "../../types";
+import { defineDockerService } from "./define-docker-service";
+import { getDefaultPortBindings, resolveHealthcheck } from "./shared";
+
+export type RedisServiceOptions = {
+	port?: number;
+	expose?: boolean;
+	healthCheck?: BuiltInHealthCheck | false;
+	serviceName?: string;
+	database?: string;
+	user?: string;
+	password?: string;
+	docker?: DockerComposeServiceRaw;
+};
+
+export const redisDockerService = defineDockerService<RedisServiceOptions>({
+	preset: "redis",
+	defaults: {
+		port: 6379,
+		healthCheck: "redis-cli",
+	},
+	build: ({ serviceKey, config }) => {
+		const defaultHealthcheck: DockerComposeHealthcheckRaw = {
+			test: ["CMD", "redis-cli", "ping"],
+			interval: "250ms",
+			timeout: "5s",
+			retries: 20,
+		};
+
+		return {
+			service: {
+				image: "redis:7-alpine",
+				ports: getDefaultPortBindings(serviceKey, config, "redis"),
+				healthcheck: resolveHealthcheck(
+					config.healthCheck,
+					defaultHealthcheck,
+					{
+						internalPort: 6379,
+					},
+				),
+			},
+		};
+	},
+});

package/src/docker-compose/services/shared.ts

@@ -0,0 +1,79 @@
+import type {
+	DockerComposeHealthcheckRaw,
+	DockerPresetName,
+	ServiceConfig,
+} from "../../types";
+
+const DEFAULT_HEALTHCHECK_SETTINGS = {
+	interval: "250ms",
+	timeout: "5s",
+	retries: 20,
+} as const;
+
+export function getPortEnvName(portKey: string): string {
+	return `${portKey.toUpperCase()}_PORT`;
+}
+
+export function getDefaultPortBindings(
+	serviceKey: string,
+	config: ServiceConfig,
+	preset?: DockerPresetName,
+): string[] {
+	const envName = getPortEnvName(serviceKey);
+	const bindings: string[] = [];
+
+	const defaultInternalPort =
+		preset === "postgres"
+			? 5432
+			: preset === "redis"
+				? 6379
+				: preset === "clickhouse"
+					? 8123
+					: config.port;
+
+	bindings.push(`\${${envName}:-${config.port}}:${defaultInternalPort}`);
+
+	if (config.secondaryPort !== undefined) {
+		const secondaryEnv = getPortEnvName(`${serviceKey}Secondary`);
+		const secondaryInternal =
+			preset === "clickhouse" ? 9000 : config.secondaryPort;
+		bindings.push(
+			`\${${secondaryEnv}:-${config.secondaryPort}}:${secondaryInternal}`,
+		);
+	}
+
+	return bindings;
+}
+
+export function resolveHealthcheck(
+	healthCheck: ServiceConfig["healthCheck"] | undefined,
+	fallback: DockerComposeHealthcheckRaw | undefined,
+	options: { internalPort: number; user?: string },
+): DockerComposeHealthcheckRaw | undefined {
+	if (healthCheck === false) return undefined;
+	if (typeof healthCheck === "function") return fallback;
+	if (!healthCheck) return fallback;
+
+	switch (healthCheck) {
+		case "pg_isready":
+			return {
+				test: ["CMD-SHELL", `pg_isready -U ${options.user ?? "postgres"}`],
+				...DEFAULT_HEALTHCHECK_SETTINGS,
+			};
+		case "redis-cli":
+			return {
+				test: ["CMD", "redis-cli", "ping"],
+				...DEFAULT_HEALTHCHECK_SETTINGS,
+			};
+		case "http":
+			return {
+				test: [
+					"CMD-SHELL",
+					`wget -qO- http://127.0.0.1:${options.internalPort}/ping || exit 1`,
+				],
+				...DEFAULT_HEALTHCHECK_SETTINGS,
+			};
+		default:
+			return fallback;
+	}
+}

package/src/docker-compose/yaml.ts

@@ -0,0 +1,88 @@
+import type { DockerComposeNode } from "../types";
+import type { ComposeDocument } from "./model";
+
+function isObject(
+	value: DockerComposeNode,
+): value is Record<string, DockerComposeNode | undefined> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function formatScalar(value: string | number | boolean | null): string {
+	if (value === null) return "null";
+	if (typeof value === "string") {
+		return JSON.stringify(value);
+	}
+	return String(value);
+}
+
+function formatKey(key: string): string {
+	return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+function sortNode(node: DockerComposeNode): DockerComposeNode {
+	if (Array.isArray(node)) {
+		return node.map(sortNode);
+	}
+	if (isObject(node)) {
+		const sorted: Record<string, DockerComposeNode | undefined> = {};
+		for (const key of Object.keys(node).sort()) {
+			const value = node[key];
+			if (value !== undefined) {
+				sorted[key] = sortNode(value);
+			}
+		}
+		return sorted;
+	}
+	return node;
+}
+
+function stringifyNode(node: DockerComposeNode, indent = 0): string {
+	const prefix = " ".repeat(indent);
+
+	if (
+		typeof node === "string" ||
+		typeof node === "number" ||
+		typeof node === "boolean" ||
+		node === null
+	) {
+		return `${prefix}${formatScalar(node)}`;
+	}
+
+	if (Array.isArray(node)) {
+		if (node.length === 0) return `${prefix}[]`;
+		return node
+			.map((item) => {
+				const isNested = typeof item === "object" && item !== null;
+				if (!isNested) {
+					return `${prefix}- ${formatScalar(
+						item as string | number | boolean | null,
+					)}`;
+				}
+				return `${prefix}-\n${stringifyNode(item, indent + 2)}`;
+			})
+			.join("\n");
+	}
+
+	const entries = Object.entries(node).filter(
+		([, value]) => value !== undefined,
+	) as Array<[string, DockerComposeNode]>;
+	if (entries.length === 0) return `${prefix}{}`;
+
+	return entries
+		.map(([key, value]) => {
+			const formattedKey = formatKey(key);
+			const isNested = typeof value === "object" && value !== null;
+			if (!isNested) {
+				return `${prefix}${formattedKey}: ${formatScalar(
+					value as string | number | boolean | null,
+				)}`;
+			}
+			return `${prefix}${formattedKey}:\n${stringifyNode(value, indent + 2)}`;
+		})
+		.join("\n");
+}
+
+export function composeToYaml(document: ComposeDocument): string {
+	const sorted = sortNode(document as DockerComposeNode);
+	return `${stringifyNode(sorted)}\n`;
+}

package/{environment.ts → src/environment/create-dev-environment.ts}

@@ -1,34 +1,38 @@
-import pc from "picocolors";
-import { assertValidConfig } from "./config";
-import {
-	areContainersRunning,
-	startContainers,
-	stopContainers,
-} from "./core/docker";
-import { getLocalIp, waitForDevServers, waitForServer } from "./core/network";
+import { assertValidConfig } from "../config";
+import { getLocalIp, waitForDevServers, waitForServer } from "../core/network";
 import {
 	computeDevIdentity,
 	computePorts,
 	computeUrls,
 	findMonorepoRoot,
-} from "./core/ports";
+} from "../core/ports";
 import {
 	buildApps,
 	execAsync,
 	startDevServers,
 	stopProcess as stopProcessFn,
-} from "./core/process";
-import { isCI as isCIEnv, logExpoApiUrl, logFrontendPort } from "./core/utils";
+} from "../core/process";
+import { isCI as isCIEnv, logExpoApiUrl, logFrontendPort } from "../core/utils";
 import {
 	spawnWatchdog as spawnWatchdogFn,
 	startHeartbeat as startHeartbeatFn,
 	stopHeartbeat as stopHeartbeatFn,
 	stopWatchdog as stopWatchdogFn,
-} from "./core/watchdog";
-import { createPrismaRunner } from "./prisma";
+} from "../core/watchdog";
+import {
+	areContainersRunning,
+	startContainers,
+	stopContainers,
+} from "../docker/runtime";
+import {
+	getGeneratedComposePath,
+	writeGeneratedComposeFile,
+} from "../docker-compose";
+import { createPrismaRunner } from "../prisma";
 import type {
 	AppConfig,
 	ComputedPorts,
+	ComputedPublicUrls,
 	ComputedUrls,
 	DevConfig,
 	DevEnvironment,
@@ -39,34 +43,9 @@ import type {
 	ServiceConfig,
 	StartOptions,
 	StopOptions,
-} from "./types";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Console Output Formatting (Vite-inspired)
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Format a URL with colored port number (Vite-style).
- */
-function formatUrl(url: string): string {
-	return pc.cyan(
-		url.replace(/:(\d+)(\/?)/, (_, port, slash) => `:${pc.bold(port)}${slash}`),
-	);
-}
-
-/**
- * Format a label with arrow prefix (Vite-style).
- */
-function formatLabel(label: string, value: string, arrow = "➜"): string {
-	return `  ${pc.green(arrow)}  ${pc.bold(label.padEnd(10))} ${value}`;
-}
-
-/**
- * Format a dim label (for secondary info).
- */
-function formatDimLabel(label: string, value: string): string {
-	return `  ${pc.dim("•")}  ${pc.dim(label.padEnd(10))} ${pc.dim(value)}`;
-}
+} from "../types";
+import { logEnvironmentInfo } from "./logging";
+import { createCheckTableHelper, createSeedCheckContext } from "./seeding";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Environment Factory
@@ -115,6 +94,14 @@ export function createDevEnvironment<
 
 	const services = config.services;
 	const apps = (config.apps ?? {}) as TApps;
+	const composeFile = getGeneratedComposePath(
+		root,
+		config.docker,
+	).composeFileArg;
+
+	function ensureComposeFile(): string {
+		return writeGeneratedComposeFile(root, services, config.docker);
+	}
 
 	// Compute ports and URLs
 	const ports = computePorts(services, apps, portOffset) as ComputedPorts<
@@ -125,6 +112,22 @@ export function createDevEnvironment<
 		TServices,
 		TApps
 	>;
+	const publicUrls: Record<string, string> = {};
+
+	function setPublicUrls(urlsInput: Record<string, string>): void {
+		for (const key of Object.keys(publicUrls)) {
+			delete publicUrls[key];
+		}
+		for (const [key, value] of Object.entries(urlsInput)) {
+			publicUrls[key] = value;
+		}
+	}
+
+	function clearPublicUrls(): void {
+		for (const key of Object.keys(publicUrls)) {
+			delete publicUrls[key];
+		}
+	}
 
 	// Build environment variables
 	function buildEnvVars(production = false): Record<string, string> {
@@ -145,12 +148,19 @@ export function createDevEnvironment<
 			baseEnv[envName] = url;
 		}
 
+		// Add public URL environment variables when tunnels are active
+		for (const [name, url] of Object.entries(publicUrls)) {
+			const envName = `${name.toUpperCase()}_PUBLIC_URL`;
+			baseEnv[envName] = url;
+		}
+
 		// Call user's envVars function if provided
 		if (config.envVars) {
 			const userEnv = config.envVars(ports, urls, {
 				projectName,
 				localIp,
 				portOffset,
+				publicUrls: publicUrls as ComputedPublicUrls<TServices, TApps>,
 			});
 			for (const [key, value] of Object.entries(userEnv)) {
 				baseEnv[key] = String(value);
@@ -169,6 +179,7 @@ export function createDevEnvironment<
 				projectName,
 				ports,
 				urls,
+				publicUrls: publicUrls as ComputedPublicUrls<TServices, TApps>,
 				root,
 				isCI: isCIEnv(),
 				portOffset,
@@ -205,6 +216,7 @@ export function createDevEnvironment<
 		} = startOptions;
 
 		const envVars = buildEnvVars(productionBuild);
+		ensureComposeFile();
 
 		// Log environment info
 		if (verbose) {
@@ -224,7 +236,7 @@ export function createDevEnvironment<
 			startContainers(root, projectName, envVars, {
 				verbose,
 				wait,
-				composeFile: config.options?.composeFile,
+				composeFile,
 			});
 		}
 
@@ -258,19 +270,19 @@ export function createDevEnvironment<
 				}),
 			);
 
-		// Check for failures
-		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);
+			// Check for failures
+			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`);
 				}
-				throw new Error(`Migration "${name}" failed`);
 			}
-		}
 
 			if (verbose) console.log("✓ Migrations complete");
 		}
@@ -286,35 +298,14 @@ export function createDevEnvironment<
 
 			// Check if seeding is needed using check function
 			if (config.seed.check) {
-				// Create checkTable helper function with typed service parameter
-				const checkTable = async (
-					tableName: string,
-					service?: keyof TServices,
-				): Promise<boolean> => {
-					const serviceName = (service ?? "postgres") as string;
-					const serviceUrl = (urls as Record<string, string>)[serviceName];
-					if (!serviceUrl) {
-						console.warn(`⚠️ Service "${serviceName}" not found for checkTable`);
-						return true; // Default to seeding if service not found
-					}
-				const checkResult = await exec(
-					`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`,
-					{ throwOnError: false },
+				const checkTable = createCheckTableHelper<TServices, TApps>(
+					urls as Record<string, string>,
+					exec,
 				);
-				const count = checkResult.stdout.trim();
-				const shouldSeed = checkResult.exitCode !== 0 || count === "0" || count === "";
-				if (!shouldSeed) {
-					console.log(`  📊 Table "${tableName}" has ${count} rows`);
-				}
-				return shouldSeed;
-				};
-
-				// Build seed check context with helpers
-				const seedCheckContext = {
-					...getHookContext(),
+				const seedCheckContext = createSeedCheckContext(
+					getHookContext(),
 					checkTable,
-				};
-
+				);
 				shouldSeed = await config.seed.check(seedCheckContext);
 			}
 
@@ -380,6 +371,7 @@ export function createDevEnvironment<
 
 	async function stop(stopOptions: StopOptions = {}): Promise<void> {
 		const { verbose = true, removeVolumes = false } = stopOptions;
+		ensureComposeFile();
 
 		// Run beforeStop hook
 		if (config.hooks?.beforeStop) {
@@ -389,7 +381,7 @@ export function createDevEnvironment<
 		stopContainers(root, projectName, {
 			verbose,
 			removeVolumes,
-			composeFile: config.options?.composeFile,
+			composeFile,
 		});
 	}
 
@@ -438,54 +430,17 @@ export function createDevEnvironment<
 	// ─────────────────────────────────────────────────────────────────────────
 
 	function logInfo(label = "Docker Dev"): void {
-		const serviceNames = Object.keys(services);
-		const appNames = Object.keys(apps);
-
-		console.log("");
-		console.log(`  ${pc.cyan(pc.bold(`🐳 ${label}`))}`);
-		console.log(formatLabel("Project:", pc.white(projectName)));
-
-		// Services section (Docker containers)
-		if (serviceNames.length > 0) {
-			console.log("");
-			console.log(`  ${pc.dim("─── Services ───")}`);
-			for (const name of serviceNames) {
-				const port = (ports as Record<string, number>)[name];
-				const url = `localhost:${port}`;
-				console.log(formatLabel(`${name}:`, formatUrl(`http://${url}`)));
-			}
-		}
-
-		// Apps section (Dev servers)
-		if (appNames.length > 0) {
-			console.log("");
-			console.log(`  ${pc.dim("─── Applications ───")}`);
-			for (const name of appNames) {
-				const port = (ports as Record<string, number>)[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)}`);
-			}
-		}
-
-		// Environment info
-		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("");
+		logEnvironmentInfo({
+			label,
+			projectName,
+			services,
+			apps,
+			ports: ports as Record<string, number>,
+			localIp,
+			worktree,
+			portOffset,
+			projectSuffix,
+		});
 	}
 
 	async function waitForServerUrl(
@@ -511,7 +466,7 @@ export function createDevEnvironment<
 		await spawnWatchdogFn(projectName, root, {
 			timeoutMinutes,
 			verbose: true,
-			composeFile: config.options?.composeFile,
+			composeFile,
 		});
 	}
 
@@ -554,11 +509,14 @@ export function createDevEnvironment<
 		projectName,
 		ports,
 		urls,
+		publicUrls: publicUrls as ComputedPublicUrls<TServices, TApps>,
+		services,
 		apps,
 		portOffset,
 		isWorktree: worktree,
 		localIp,
 		root,
+		composeFile,
 
 		// Container management
 		start,
@@ -573,6 +531,11 @@ export function createDevEnvironment<
 
 		// Utilities
 		buildEnvVars,
+		setPublicUrls: (urlsInput) => {
+			setPublicUrls(urlsInput as Record<string, string>);
+		},
+		clearPublicUrls,
+		ensureComposeFile,
 		exec,
 		waitForServer: waitForServerUrl,
 		logInfo,