buncargo 1.0.29 → 3.0.0

package/dist/index-tjbx2r2t.js

@@ -0,0 +1,270 @@
+// src/docker/runtime.ts
+import { execSync } from "node:child_process";
+import { sleep } from "./index-4gp0az1g.js";
+
+var POLL_INTERVAL = 250;
+var MAX_ATTEMPTS = 120;
+var DOCKER_NOT_RUNNING_MESSAGE =
+	"Docker is not running. Please start Docker and try again.";
+async function isContainerRunning(project, service) {
+	try {
+		const result = execSync(
+			`docker ps --filter "label=com.docker.compose.project=${project}" --filter "label=com.docker.compose.service=${service}" --format "{{.State}}"`,
+			{ encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+		);
+		return result.trim() === "running";
+	} catch {
+		return false;
+	}
+}
+function isDockerRunning() {
+	try {
+		execSync('docker info --format "{{.ServerVersion}}"', {
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function assertDockerRunning() {
+	if (!isDockerRunning()) {
+		throw new Error(DOCKER_NOT_RUNNING_MESSAGE);
+	}
+}
+async function areContainersRunning(project, minCount = 1) {
+	try {
+		const result = execSync(
+			`docker ps --filter "label=com.docker.compose.project=${project}" --format "{{.State}}"`,
+			{ encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+		);
+		const states = result
+			.trim()
+			.split(`
+`)
+			.filter(Boolean);
+		if (states.length < minCount) return false;
+		return states.every((state) => state === "running");
+	} catch {
+		return false;
+	}
+}
+function getComposeArg(composeFile) {
+	return composeFile ? `-f "${composeFile}"` : "";
+}
+function startContainers(root, projectName, envVars, options = {}) {
+	const { verbose = true, wait = true, composeFile } = options;
+	assertDockerRunning();
+	if (verbose) console.log("\uD83D\uDC33 Starting Docker containers...");
+	const composeArg = getComposeArg(composeFile);
+	const waitFlag = wait ? "--wait" : "";
+	const cmd = `docker compose ${composeArg} up -d ${waitFlag}`.trim();
+	execSync(cmd, {
+		cwd: root,
+		env: { ...process.env, ...envVars, COMPOSE_PROJECT_NAME: projectName },
+		stdio: verbose ? "inherit" : "ignore",
+	});
+	if (verbose) console.log("✓ Containers started");
+}
+function stopContainers(root, projectName, options = {}) {
+	const { verbose = true, removeVolumes = false, composeFile } = options;
+	assertDockerRunning();
+	if (verbose) {
+		console.log(
+			removeVolumes
+				? "\uD83D\uDDD1️  Stopping containers and removing volumes..."
+				: "\uD83D\uDED1 Stopping containers...",
+		);
+	}
+	const composeArg = getComposeArg(composeFile);
+	const volumeFlag = removeVolumes ? "-v" : "";
+	const cmd = `docker compose ${composeArg} down ${volumeFlag}`.trim();
+	execSync(cmd, {
+		cwd: root,
+		env: { ...process.env, COMPOSE_PROJECT_NAME: projectName },
+		stdio: verbose ? "inherit" : "ignore",
+	});
+	if (verbose) console.log("✓ Containers stopped");
+}
+function startService(root, projectName, serviceName, envVars, options = {}) {
+	const { verbose = true, composeFile } = options;
+	assertDockerRunning();
+	if (verbose) console.log(`\uD83D\uDC33 Starting ${serviceName}...`);
+	const composeArg = getComposeArg(composeFile);
+	const cmd = `docker compose ${composeArg} up -d ${serviceName}`.trim();
+	execSync(cmd, {
+		cwd: root,
+		env: { ...process.env, ...envVars, COMPOSE_PROJECT_NAME: projectName },
+		stdio: verbose ? "inherit" : "ignore",
+	});
+}
+function createBuiltInHealthCheck(type, serviceName, context = {}) {
+	const { projectName, root } = context;
+	switch (type) {
+		case "pg_isready":
+			return async () => {
+				try {
+					const projectArg = projectName ? `-p ${projectName}` : "";
+					execSync(
+						`docker compose ${projectArg} exec -T ${serviceName} pg_isready -U postgres`,
+						{
+							cwd: root,
+							stdio: ["pipe", "pipe", "pipe"],
+						},
+					);
+					return true;
+				} catch {
+					return false;
+				}
+			};
+		case "redis-cli":
+			return async () => {
+				try {
+					const projectArg = projectName ? `-p ${projectName}` : "";
+					execSync(
+						`docker compose ${projectArg} exec -T ${serviceName} redis-cli ping`,
+						{
+							cwd: root,
+							stdio: ["pipe", "pipe", "pipe"],
+						},
+					);
+					return true;
+				} catch {
+					return false;
+				}
+			};
+		case "http":
+			return async (port) => {
+				try {
+					const controller = new AbortController();
+					const timeoutId = setTimeout(() => controller.abort(), 2000);
+					try {
+						const response = await fetch(`http://localhost:${port}/`, {
+							signal: controller.signal,
+						});
+						clearTimeout(timeoutId);
+						return response.ok || response.status === 404;
+					} catch {
+						clearTimeout(timeoutId);
+						return false;
+					}
+				} catch {
+					return false;
+				}
+			};
+		case "tcp":
+			return async (port) => {
+				try {
+					const controller = new AbortController();
+					const timeoutId = setTimeout(() => controller.abort(), 1000);
+					try {
+						await fetch(`http://localhost:${port}/`, {
+							signal: controller.signal,
+						});
+						clearTimeout(timeoutId);
+						return true;
+					} catch (error) {
+						clearTimeout(timeoutId);
+						if (
+							error instanceof Error &&
+							error.message.includes("ECONNREFUSED")
+						) {
+							return false;
+						}
+						return true;
+					}
+				} catch {
+					return false;
+				}
+			};
+		default:
+			return async () => true;
+	}
+}
+async function waitForService(serviceName, config, port, options = {}) {
+	const {
+		maxAttempts = MAX_ATTEMPTS,
+		pollInterval = POLL_INTERVAL,
+		projectName,
+		root,
+	} = options;
+	if (config.healthCheck === false || config.healthCheck === undefined) {
+		return;
+	}
+	const healthCheckFn =
+		typeof config.healthCheck === "function"
+			? config.healthCheck
+			: createBuiltInHealthCheck(
+					config.healthCheck,
+					config.serviceName ?? serviceName,
+					{ projectName, root },
+				);
+	for (let i = 0; i < maxAttempts; i++) {
+		const isHealthy = await healthCheckFn(port);
+		if (isHealthy) return;
+		await sleep(pollInterval);
+	}
+	throw new Error(`Service ${serviceName} did not become ready in time`);
+}
+async function waitForAllServices(services, ports, options = {}) {
+	const { verbose = true, ...waitOptions } = options;
+	if (verbose) console.log("⏳ Waiting for services to be healthy...");
+	const promises = Object.entries(services).map(([name, config]) => {
+		const port = ports[name];
+		if (port === undefined) {
+			console.warn(
+				`⚠️  No port found for service ${name}, skipping health check`,
+			);
+			return Promise.resolve();
+		}
+		return waitForService(name, config, port, waitOptions);
+	});
+	await Promise.all(promises);
+	if (verbose) console.log("✓ All services healthy");
+}
+async function waitForServiceByType(
+	serviceName,
+	healthCheckType,
+	port,
+	options = {},
+) {
+	const {
+		maxAttempts = MAX_ATTEMPTS,
+		pollInterval = POLL_INTERVAL,
+		verbose = false,
+		projectName,
+		root,
+	} = options;
+	const healthCheckFn = createBuiltInHealthCheck(healthCheckType, serviceName, {
+		projectName,
+		root,
+	});
+	for (let i = 0; i < maxAttempts; i++) {
+		const isHealthy = await healthCheckFn(port);
+		if (isHealthy) {
+			if (verbose) console.log(`✓ ${serviceName} is ready`);
+			return;
+		}
+		await sleep(pollInterval);
+	}
+	throw new Error(`Service ${serviceName} did not become ready in time`);
+}
+
+export {
+	POLL_INTERVAL,
+	MAX_ATTEMPTS,
+	DOCKER_NOT_RUNNING_MESSAGE,
+	isContainerRunning,
+	isDockerRunning,
+	assertDockerRunning,
+	areContainersRunning,
+	getComposeArg,
+	startContainers,
+	stopContainers,
+	startService,
+	createBuiltInHealthCheck,
+	waitForService,
+	waitForAllServices,
+	waitForServiceByType,
+};

package/dist/index-tjqw9vtj.js

@@ -1,68 +1,76 @@
 // config.ts
 function defineDevConfig(config) {
-  return config;
+	return config;
 }
 function validateConfig(config) {
-  const errors = [];
-  if (!config.projectPrefix) {
-    errors.push("projectPrefix is required");
-  } else if (!/^[a-z][a-z0-9-]*$/.test(config.projectPrefix)) {
-    errors.push("projectPrefix must start with a letter and contain only lowercase letters, numbers, and hyphens");
-  }
-  if (!config.services || Object.keys(config.services).length === 0) {
-    errors.push("At least one service is required");
-  }
-  for (const [name, service] of Object.entries(config.services ?? {})) {
-    if (!service.port || typeof service.port !== "number") {
-      errors.push(`Service "${name}" must have a valid port number`);
-    }
-    if (service.port < 1 || service.port > 65535) {
-      errors.push(`Service "${name}" port must be between 1 and 65535`);
-    }
-  }
-  for (const [name, app] of Object.entries(config.apps ?? {})) {
-    if (!app.port || typeof app.port !== "number") {
-      errors.push(`App "${name}" must have a valid port number`);
-    }
-    if (!app.devCommand) {
-      errors.push(`App "${name}" must have a devCommand`);
-    }
-  }
-  for (const migration of config.migrations ?? []) {
-    if (!migration.name) {
-      errors.push("Migration must have a name");
-    }
-    if (!migration.command) {
-      errors.push(`Migration "${migration.name}" must have a command`);
-    }
-  }
-  if (config.seed && !config.seed.command) {
-    errors.push("Seed must have a command");
-  }
-  return errors;
+	const errors = [];
+	if (!config.projectPrefix) {
+		errors.push("projectPrefix is required");
+	} else if (!/^[a-z][a-z0-9-]*$/.test(config.projectPrefix)) {
+		errors.push(
+			"projectPrefix must start with a letter and contain only lowercase letters, numbers, and hyphens",
+		);
+	}
+	if (!config.services || Object.keys(config.services).length === 0) {
+		errors.push("At least one service is required");
+	}
+	for (const [name, service] of Object.entries(config.services ?? {})) {
+		if (!service.port || typeof service.port !== "number") {
+			errors.push(`Service "${name}" must have a valid port number`);
+		}
+		if (service.port < 1 || service.port > 65535) {
+			errors.push(`Service "${name}" port must be between 1 and 65535`);
+		}
+	}
+	for (const [name, app] of Object.entries(config.apps ?? {})) {
+		if (!app.port || typeof app.port !== "number") {
+			errors.push(`App "${name}" must have a valid port number`);
+		}
+		if (!app.devCommand) {
+			errors.push(`App "${name}" must have a devCommand`);
+		}
+	}
+	for (const migration of config.migrations ?? []) {
+		if (!migration.name) {
+			errors.push("Migration must have a name");
+		}
+		if (!migration.command) {
+			errors.push(`Migration "${migration.name}" must have a command`);
+		}
+	}
+	if (config.seed && !config.seed.command) {
+		errors.push("Seed must have a command");
+	}
+	return errors;
 }
 function assertValidConfig(config) {
-  const errors = validateConfig(config);
-  if (errors.length > 0) {
-    throw new Error(`Invalid dev config:
+	const errors = validateConfig(config);
+	if (errors.length > 0) {
+		throw new Error(`Invalid dev config:
   - ${errors.join(`
   - `)}`);
-  }
+	}
 }
 function mergeConfigs(base, overrides) {
-  return {
-    ...base,
-    ...overrides,
-    services: { ...base.services, ...overrides.services },
-    apps: { ...base.apps, ...overrides.apps },
-    hooks: { ...base.hooks, ...overrides.hooks },
-    migrations: overrides.migrations ?? base.migrations,
-    seed: overrides.seed ?? base.seed,
-    options: { ...base.options, ...overrides.options }
-  };
+	return {
+		...base,
+		...overrides,
+		services: { ...base.services, ...overrides.services },
+		apps: { ...base.apps, ...overrides.apps },
+		hooks: { ...base.hooks, ...overrides.hooks },
+		migrations: overrides.migrations ?? base.migrations,
+		seed: overrides.seed ?? base.seed,
+		options: { ...base.options, ...overrides.options },
+	};
 }
 function definePartialConfig(config) {
-  return config;
+	return config;
 }
 
-export { defineDevConfig, validateConfig, assertValidConfig, mergeConfigs, definePartialConfig };
+export {
+	defineDevConfig,
+	validateConfig,
+	assertValidConfig,
+	mergeConfigs,
+	definePartialConfig,
+};

package/dist/index-vbpb89jy.js

@@ -0,0 +1,248 @@
+// src/docker-compose/generated-file.ts
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import {
+	buildPresetDockerService,
+	getDefaultPortBindings,
+	inferDockerPreset,
+} from "./index-w8zxnjka.js";
+
+// src/docker-compose/model.ts
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMergeNode(base, override) {
+	if (Array.isArray(base) || Array.isArray(override)) {
+		return override;
+	}
+	if (!isObject(base) || !isObject(override)) {
+		return override;
+	}
+	const merged = { ...base };
+	for (const key of Object.keys(override)) {
+		const baseValue = merged[key];
+		const overrideValue = override[key];
+		if (baseValue === undefined || overrideValue === undefined) {
+			merged[key] = overrideValue;
+		} else {
+			merged[key] = deepMergeNode(baseValue, overrideValue);
+		}
+	}
+	return merged;
+}
+function isPresetDefinition(value) {
+	return Boolean(
+		value &&
+			typeof value === "object" &&
+			"kind" in value &&
+			value.kind === "preset",
+	);
+}
+function normalizeRawService(name, config, service) {
+	const normalized = { ...service };
+	if (!normalized.ports || normalized.ports.length === 0) {
+		normalized.ports = getDefaultPortBindings(name, config);
+	}
+	if (config.healthCheck === false) {
+		delete normalized.healthcheck;
+	}
+	return normalized;
+}
+function normalizeServiceConfig(name, config) {
+	const serviceName = config.serviceName ?? name;
+	const rawDefinition = config.docker;
+	if (isPresetDefinition(rawDefinition)) {
+		return {
+			kind: "preset",
+			serviceName,
+			preset: rawDefinition.preset,
+			serviceOverride: rawDefinition.service,
+		};
+	}
+	if (rawDefinition) {
+		const inferredPreset = inferDockerPreset(name);
+		if (inferredPreset) {
+			return {
+				kind: "preset",
+				serviceName,
+				preset: inferredPreset,
+				serviceOverride: rawDefinition,
+			};
+		}
+		return {
+			kind: "raw",
+			serviceName,
+			service: normalizeRawService(name, config, rawDefinition),
+		};
+	}
+	const preset = inferDockerPreset(name);
+	if (!preset) {
+		throw new Error(
+			`Service "${name}" has no docker preset and no docker definition. Add service.docker using helper or raw mode.`,
+		);
+	}
+	return {
+		kind: "preset",
+		serviceName,
+		preset,
+	};
+}
+function resolveServiceDefinition(name, config) {
+	const normalized = normalizeServiceConfig(name, config);
+	if (normalized.kind === "raw") {
+		return {
+			serviceName: normalized.serviceName,
+			service: normalized.service,
+		};
+	}
+	const { service, volume } = buildPresetDockerService(normalized.preset, {
+		serviceKey: name,
+		config,
+	});
+	const mergedService = normalized.serviceOverride
+		? deepMergeNode(service, normalized.serviceOverride)
+		: service;
+	return {
+		serviceName: normalized.serviceName,
+		service: mergedService,
+		volume,
+	};
+}
+function buildComposeModel(services, docker) {
+	const composeServices = {};
+	const composeVolumes = {};
+	for (const [name, serviceConfig] of Object.entries(services)) {
+		const { serviceName, service, volume } = resolveServiceDefinition(
+			name,
+			serviceConfig,
+		);
+		composeServices[serviceName] = service;
+		if (volume) {
+			composeVolumes[volume] = {};
+		}
+	}
+	for (const [volumeName, volume] of Object.entries(docker?.volumes ?? {})) {
+		composeVolumes[volumeName] = volume;
+	}
+	const document = {
+		services: composeServices,
+	};
+	if (Object.keys(composeVolumes).length > 0) {
+		document.volumes = composeVolumes;
+	}
+	return document;
+}
+
+// src/docker-compose/yaml.ts
+function isObject2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatScalar(value) {
+	if (value === null) return "null";
+	if (typeof value === "string") {
+		return JSON.stringify(value);
+	}
+	return String(value);
+}
+function formatKey(key) {
+	return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+}
+function sortNode(node) {
+	if (Array.isArray(node)) {
+		return node.map(sortNode);
+	}
+	if (isObject2(node)) {
+		const sorted = {};
+		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, indent = 0) {
+	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)}`;
+				}
+				return `${prefix}-
+${stringifyNode(item, indent + 2)}`;
+			})
+			.join(`
+`);
+	}
+	const entries = Object.entries(node).filter(
+		([, value]) => value !== undefined,
+	);
+	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)}`;
+			}
+			return `${prefix}${formattedKey}:
+${stringifyNode(value, indent + 2)}`;
+		})
+		.join(`
+`);
+}
+function composeToYaml(document) {
+	const sorted = sortNode(document);
+	return `${stringifyNode(sorted)}
+`;
+}
+
+// src/docker-compose/generated-file.ts
+var DEFAULT_GENERATED_COMPOSE_FILE = ".buncargo/docker-compose.generated.yml";
+function getGeneratedComposePath(root, docker) {
+	const generatedFile = docker?.generatedFile ?? DEFAULT_GENERATED_COMPOSE_FILE;
+	const absolutePath = isAbsolute(generatedFile)
+		? generatedFile
+		: resolve(root, generatedFile);
+	const relativePath = relative(root, absolutePath);
+	const composeFileArg =
+		relativePath && !relativePath.startsWith("..")
+			? relativePath
+			: absolutePath;
+	return { absolutePath, composeFileArg };
+}
+function writeGeneratedComposeFile(root, services, docker) {
+	const { absolutePath, composeFileArg } = getGeneratedComposePath(
+		root,
+		docker,
+	);
+	const writeStrategy = docker?.writeStrategy ?? "always";
+	const shouldWrite = writeStrategy === "always" || !existsSync(absolutePath);
+	if (shouldWrite) {
+		const composeModel = buildComposeModel(services, docker);
+		const yaml = composeToYaml(composeModel);
+		mkdirSync(dirname(absolutePath), { recursive: true });
+		writeFileSync(absolutePath, yaml, "utf-8");
+	}
+	return composeFileArg;
+}
+export {
+	buildComposeModel,
+	composeToYaml,
+	DEFAULT_GENERATED_COMPOSE_FILE,
+	getGeneratedComposePath,
+	writeGeneratedComposeFile,
+};