buncargo 1.0.29 → 3.2.0

package/dist/index-segbnm0h.js

@@ -1,24 +1,22 @@
+// cli.ts
+import { spawn } from "node:child_process";
+import { killProcessesOnAppPorts } from "./index-1yvbwj4k.js";
 import {
-  spawnWatchdog,
-  startHeartbeat,
-  stopHeartbeat
+	spawnWatchdog,
+	startHeartbeat,
+	stopHeartbeat,
 } from "./index-ggq3yryx.js";
-import {
-  killProcessesOnAppPorts
-} from "./index-1yvbwj4k.js";
 
-// cli.ts
-import { spawn } from "node:child_process";
 var ACCEPTED_FLAGS = [
-  "--help",
-  "--down",
-  "--reset",
-  "--migrate",
-  "--seed",
-  "--up-only"
+	"--help",
+	"--down",
+	"--reset",
+	"--migrate",
+	"--seed",
+	"--up-only",
 ];
 function printHelp() {
-  console.log(`
+	console.log(`
 Usage: buncargo dev [options]
 
 Options:
@@ -37,144 +35,149 @@ Examples:
 `);
 }
 function getUnknownFlags(args) {
-  return args.filter((arg) => arg.startsWith("--") && !ACCEPTED_FLAGS.includes(arg));
+	return args.filter(
+		(arg) => arg.startsWith("--") && !ACCEPTED_FLAGS.includes(arg),
+	);
 }
 async function runCli(env, options = {}) {
-  const {
-    args = process.argv.slice(2),
-    watchdog = true,
-    watchdogTimeout = 10,
-    devServersCommand
-  } = options;
-  if (args.includes("--help")) {
-    printHelp();
-    process.exit(0);
-  }
-  const unknownFlags = getUnknownFlags(args);
-  if (unknownFlags.length > 0) {
-    console.error(`❌ Unknown flag${unknownFlags.length > 1 ? "s" : ""}: ${unknownFlags.join(", ")}`);
-    console.error("");
-    printHelp();
-    process.exit(1);
-  }
-  if (args.includes("--down")) {
-    env.logInfo();
-    await env.stop();
-    process.exit(0);
-  }
-  if (args.includes("--reset")) {
-    env.logInfo();
-    await env.stop({ removeVolumes: true });
-    process.exit(0);
-  }
-  const skipSeed = args.includes("--seed");
-  await env.start({ startServers: false, wait: true, skipSeed });
-  if (args.includes("--migrate")) {
-    console.log("");
-    console.log("✅ Migrations applied successfully");
-    process.exit(0);
-  }
-  if (args.includes("--seed")) {
-    console.log("\uD83C\uDF31 Running seeders...");
-    const result = await env.exec("bun run run:seeder", {
-      throwOnError: false
-    });
-    if (result.exitCode !== 0) {
-      console.error("❌ Seeding failed");
-      if (result.stderr) {
-        console.error(result.stderr);
-      }
-      if (result.stdout) {
-        console.error(result.stdout);
-      }
-      process.exit(1);
-    }
-    console.log("");
-    console.log("✅ Seeding complete");
-    process.exit(0);
-  }
-  if (args.includes("--up-only")) {
-    console.log("");
-    console.log("✅ Containers started. Environment ready.");
-    console.log("");
-    process.exit(0);
-  }
-  if (watchdog) {
-    await spawnWatchdog(env.projectName, env.root, {
-      timeoutMinutes: watchdogTimeout,
-      verbose: true
-    });
-    startHeartbeat(env.projectName);
-  }
-  const command = devServersCommand ?? buildDevServersCommand(env.apps);
-  if (!command) {
-    console.log("✅ Containers ready. No apps configured.");
-    await new Promise(() => {});
-    return;
-  }
-  await killProcessesOnAppPorts(env.apps, env.ports);
-  console.log("");
-  console.log("\uD83D\uDD27 Starting dev servers...");
-  console.log("");
-  await runCommand(command, env.root, env.buildEnvVars());
-  stopHeartbeat();
+	const {
+		args = process.argv.slice(2),
+		watchdog = true,
+		watchdogTimeout = 10,
+		devServersCommand,
+	} = options;
+	if (args.includes("--help")) {
+		printHelp();
+		process.exit(0);
+	}
+	const unknownFlags = getUnknownFlags(args);
+	if (unknownFlags.length > 0) {
+		console.error(
+			`❌ Unknown flag${unknownFlags.length > 1 ? "s" : ""}: ${unknownFlags.join(", ")}`,
+		);
+		console.error("");
+		printHelp();
+		process.exit(1);
+	}
+	if (args.includes("--down")) {
+		env.logInfo();
+		await env.stop();
+		process.exit(0);
+	}
+	if (args.includes("--reset")) {
+		env.logInfo();
+		await env.stop({ removeVolumes: true });
+		process.exit(0);
+	}
+	const skipSeed = args.includes("--seed");
+	await env.start({ startServers: false, wait: true, skipSeed });
+	if (args.includes("--migrate")) {
+		console.log("");
+		console.log("✅ Migrations applied successfully");
+		process.exit(0);
+	}
+	if (args.includes("--seed")) {
+		console.log("\uD83C\uDF31 Running seeders...");
+		const result = await env.exec("bun run run:seeder", {
+			throwOnError: false,
+		});
+		if (result.exitCode !== 0) {
+			console.error("❌ Seeding failed");
+			if (result.stderr) {
+				console.error(result.stderr);
+			}
+			if (result.stdout) {
+				console.error(result.stdout);
+			}
+			process.exit(1);
+		}
+		console.log("");
+		console.log("✅ Seeding complete");
+		process.exit(0);
+	}
+	if (args.includes("--up-only")) {
+		console.log("");
+		console.log("✅ Containers started. Environment ready.");
+		console.log("");
+		process.exit(0);
+	}
+	if (watchdog) {
+		await spawnWatchdog(env.projectName, env.root, {
+			timeoutMinutes: watchdogTimeout,
+			verbose: true,
+		});
+		startHeartbeat(env.projectName);
+	}
+	const command = devServersCommand ?? buildDevServersCommand(env.apps);
+	if (!command) {
+		console.log("✅ Containers ready. No apps configured.");
+		await new Promise(() => {});
+		return;
+	}
+	await killProcessesOnAppPorts(env.apps, env.ports);
+	console.log("");
+	console.log("\uD83D\uDD27 Starting dev servers...");
+	console.log("");
+	await runCommand(command, env.root, env.buildEnvVars());
+	stopHeartbeat();
 }
 function buildDevServersCommand(apps) {
-  const appEntries = Object.entries(apps);
-  if (appEntries.length === 0)
-    return null;
-  const commands = [];
-  const names = [];
-  const colors = ["blue", "green", "yellow", "magenta", "cyan", "red"];
-  for (const [name, config] of appEntries) {
-    names.push(name);
-    const cwdPart = config.cwd ? `--cwd ${config.cwd}` : "";
-    commands.push(`"bun run ${cwdPart} ${config.devCommand}"`.replace(/\s+/g, " ").trim());
-  }
-  const namesArg = `-n ${names.join(",")}`;
-  const colorsArg = `-c ${colors.slice(0, names.length).join(",")}`;
-  const commandsArg = commands.join(" ");
-  return `bun concurrently ${namesArg} ${colorsArg} ${commandsArg}`;
+	const appEntries = Object.entries(apps);
+	if (appEntries.length === 0) return null;
+	const commands = [];
+	const names = [];
+	const colors = ["blue", "green", "yellow", "magenta", "cyan", "red"];
+	for (const [name, config] of appEntries) {
+		names.push(name);
+		const cwdPart = config.cwd ? `--cwd ${config.cwd}` : "";
+		commands.push(
+			`"bun run ${cwdPart} ${config.devCommand}"`.replace(/\s+/g, " ").trim(),
+		);
+	}
+	const namesArg = `-n ${names.join(",")}`;
+	const colorsArg = `-c ${colors.slice(0, names.length).join(",")}`;
+	const commandsArg = commands.join(" ");
+	return `bun concurrently ${namesArg} ${colorsArg} ${commandsArg}`;
 }
 function runCommand(command, cwd, envVars) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, [], {
-      cwd,
-      env: { ...process.env, ...envVars },
-      stdio: "inherit",
-      shell: true
-    });
-    proc.on("close", (code) => {
-      if (code === 0 || code === null) {
-        resolve();
-      } else {
-        reject(new Error(`Command exited with code ${code}`));
-      }
-    });
-    proc.on("error", reject);
-    const cleanup = () => {
-      proc.kill("SIGTERM");
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-  });
+	return new Promise((resolve, reject) => {
+		const proc = spawn(command, [], {
+			cwd,
+			env: { ...process.env, ...envVars },
+			stdio: "inherit",
+			shell: true,
+		});
+		proc.on("close", (code) => {
+			if (code === 0 || code === null) {
+				resolve();
+			} else {
+				reject(new Error(`Command exited with code ${code}`));
+			}
+		});
+		proc.on("error", reject);
+		const cleanup = () => {
+			proc.kill("SIGTERM");
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	});
 }
 function hasFlag(args, flag) {
-  return args.includes(flag);
+	return args.includes(flag);
 }
 function getFlagValue(args, flag) {
-  const prefixed = args.find((arg) => arg.startsWith(`${flag}=`));
-  if (prefixed) {
-    return prefixed.split("=")[1];
-  }
-  const index = args.indexOf(flag);
-  if (index !== -1 && index + 1 < args.length) {
-    const nextArg = args[index + 1];
-    if (nextArg !== undefined && !nextArg.startsWith("-")) {
-      return nextArg;
-    }
-  }
-  return;
+	const prefixed = args.find((arg) => arg.startsWith(`${flag}=`));
+	if (prefixed) {
+		return prefixed.split("=")[1];
+	}
+	const index = args.indexOf(flag);
+	if (index !== -1 && index + 1 < args.length) {
+		const nextArg = args[index + 1];
+		if (nextArg !== undefined && !nextArg.startsWith("-")) {
+			return nextArg;
+		}
+	}
+	return;
 }
 
 export { runCli, hasFlag, getFlagValue };

package/dist/index-t0fj6gg1.js

@@ -0,0 +1,112 @@
+// src/config/define-config.ts
+function defineDevConfig(config) {
+  return config;
+}
+// src/config/merge-configs.ts
+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 },
+    docker: { ...base.docker, ...overrides.docker }
+  };
+}
+function definePartialConfig(config) {
+  return config;
+}
+// src/config/validate-config.ts
+import { isAbsolute, normalize } from "node:path";
+var BUILTIN_DOCKER_PRESETS = new Set(["postgres", "redis", "clickhouse"]);
+function inferBuiltInPreset(serviceName) {
+  const normalized = serviceName.toLowerCase();
+  return BUILTIN_DOCKER_PRESETS.has(normalized) ? normalized : null;
+}
+function validateConfig(config) {
+  const errors = [];
+  const composeServiceNames = new Set;
+  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`);
+    }
+    if (service.secondaryPort !== undefined && (service.secondaryPort < 1 || service.secondaryPort > 65535)) {
+      errors.push(`Service "${name}" secondaryPort must be between 1 and 65535`);
+    }
+    const composeServiceName = service.serviceName ?? name;
+    if (composeServiceNames.has(composeServiceName)) {
+      errors.push(`Duplicate compose service name "${composeServiceName}". Use unique serviceName values.`);
+    }
+    composeServiceNames.add(composeServiceName);
+    const dockerConfig = service.docker;
+    const preset = inferBuiltInPreset(name);
+    if (!dockerConfig && !preset) {
+      errors.push(`Service "${name}" must define docker config (helper or raw) because it has no built-in preset.`);
+    }
+    if (dockerConfig && typeof dockerConfig === "object" && "kind" in dockerConfig && dockerConfig.kind === "preset") {
+      const presetName = dockerConfig.preset;
+      if (typeof presetName !== "string" || !BUILTIN_DOCKER_PRESETS.has(presetName)) {
+        errors.push(`Service "${name}" has invalid docker preset "${presetName}".`);
+      }
+    }
+  }
+  if (config.docker?.writeStrategy) {
+    const writeStrategy = config.docker.writeStrategy;
+    if (writeStrategy !== "always" && writeStrategy !== "if-missing") {
+      errors.push(`docker.writeStrategy "${String(writeStrategy)}" is invalid. Use "always" or "if-missing".`);
+    }
+  }
+  if (config.docker?.generatedFile) {
+    const generatedFile = config.docker.generatedFile;
+    if (isAbsolute(generatedFile)) {
+      errors.push("docker.generatedFile must be a relative path inside the repo.");
+    }
+    const normalized = normalize(generatedFile).replace(/\\/g, "/");
+    if (normalized === ".." || normalized.startsWith("../")) {
+      errors.push("docker.generatedFile cannot point outside the repository root.");
+    }
+  }
+  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:
+  - ${errors.join(`
+  - `)}`);
+  }
+}
+export { defineDevConfig, mergeConfigs, definePartialConfig, validateConfig, assertValidConfig };

package/dist/index-thdkwnv7.js

@@ -0,0 +1,122 @@
+import {
+  calculatePortOffset,
+  computePorts,
+  computeUrls
+} from "./index-fb29934k.js";
+
+// src/core/network.ts
+import { networkInterfaces } from "node:os";
+function getLocalIp() {
+  const interfaces = networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    const nets = interfaces[name];
+    if (!nets)
+      continue;
+    for (const net of nets) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+async function waitForServer(url, options = {}) {
+  const { timeout = 30000, interval = 2000, verbose = false } = options;
+  const start = Date.now();
+  let attempts = 0;
+  while (Date.now() - start < timeout) {
+    attempts++;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    try {
+      const response = await fetch(url, {
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok || response.status === 404) {
+        if (verbose) {
+          console.log(`   ✓ ${url} ready after ${attempts} attempts`);
+        }
+        return;
+      }
+    } catch {
+      clearTimeout(timeoutId);
+      if (verbose && attempts % 5 === 0) {
+        console.log(`   ⏳ Waiting for ${url}... (${Math.round((Date.now() - start) / 1000)}s)`);
+      }
+    }
+    await sleep(interval);
+  }
+  throw new Error(`Server at ${url} did not respond within ${timeout}ms after ${attempts} attempts`);
+}
+async function waitForDevServers(apps, ports, options = {}) {
+  const { timeout = 60000, verbose = true } = options;
+  if (verbose)
+    console.log("⏳ Waiting for servers to be ready...");
+  const promises = [];
+  for (const [name, config] of Object.entries(apps)) {
+    const port = ports[name];
+    const healthPath = config.healthEndpoint ?? "/";
+    const url = `http://localhost:${port}${healthPath}`;
+    const appTimeout = config.healthTimeout ?? timeout;
+    promises.push(waitForServer(url, { timeout: appTimeout, verbose }));
+  }
+  await Promise.all(promises);
+  if (verbose)
+    console.log("✓ All servers ready");
+}
+async function isPortAvailable(port) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), 500);
+  try {
+    const _response = await fetch(`http://localhost:${port}/`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return false;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error) {
+      if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+        return true;
+      }
+    }
+    return true;
+  }
+}
+
+// src/core/utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isCI() {
+  return process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true" || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true" || process.env.JENKINS_URL !== undefined;
+}
+function logFrontendPort(port) {
+  console.log(`using_frontend_port:${port}`);
+}
+function getEnvVar(config, name, options = {}) {
+  const { log = true } = options;
+  const offset = calculatePortOffset();
+  const localIp = getLocalIp();
+  const ports = computePorts(config.services, config.apps, offset);
+  const urls = computeUrls(config.services, config.apps, ports, localIp);
+  const envVars = config.envVars?.(ports, urls, {
+    projectName: config.projectPrefix,
+    localIp,
+    portOffset: offset
+  });
+  const value = envVars?.[name];
+  if (log && name === "VITE_PORT" && typeof value === "number") {
+    logFrontendPort(value);
+  }
+  return value;
+}
+function logApiUrl(url) {
+  console.log(`using_api_url:${url}`);
+}
+function logExpoApiUrl(url) {
+  console.log(`using_expo_api_url:${url}`);
+}
+
+export { sleep, isCI, logFrontendPort, getEnvVar, logApiUrl, logExpoApiUrl, getLocalIp, waitForServer, waitForDevServers, isPortAvailable };