buncargo 1.0.29 → 3.2.0

package/dist/index-vs81yaks.js

@@ -0,0 +1,244 @@
+import {
+  resolveExposeTargets,
+  startPublicTunnels,
+  stopPublicTunnels
+} from "./index-yz4jfz7z.js";
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat
+} from "./index-mam0bcyz.js";
+import {
+  killProcessesOnAppPorts
+} from "./index-mm412dkp.js";
+
+// src/cli/run-cli.ts
+import { spawn } from "node:child_process";
+var ACCEPTED_FLAGS = [
+  "--help",
+  "--down",
+  "--reset",
+  "--migrate",
+  "--seed",
+  "--up-only",
+  "--expose"
+];
+function printHelp() {
+  console.log(`
+Usage: buncargo dev [options]
+
+Options:
+  --help      Show this help message
+  --down      Stop all containers
+  --reset     Stop containers and remove volumes (fresh start)
+  --migrate   Run migrations and exit
+  --seed      Run migrations and seeders, then exit
+  --up-only   Start containers and run migrations, then exit (no dev servers)
+  --expose    Expose configured targets via public quick tunnels
+
+Examples:
+  bun dev              Start dev environment with all services
+  bun dev --seed       Run migrations and seed the database
+  bun dev --down       Stop all containers
+  bun dev --reset      Stop containers and remove all data
+  bun dev --expose     Expose all targets with expose: true
+  bun dev --expose=api,web  Expose specific targets
+`);
+}
+function getUnknownFlags(args) {
+  return args.filter((arg) => arg.startsWith("--") && !ACCEPTED_FLAGS.includes(arg.includes("=") ? arg.split("=")[0] : arg));
+}
+async function runCli(env, options = {}) {
+  const {
+    args = process.argv.slice(2),
+    watchdog = true,
+    watchdogTimeout = 10,
+    devServersCommand
+  } = options;
+  const exposeRequested = hasFlag(args, "--expose");
+  const exposeValue = getFlagValue(args, "--expose");
+  let tunnels = [];
+  async function cleanupTunnels() {
+    env.clearPublicUrls();
+    if (tunnels.length === 0)
+      return;
+    await stopPublicTunnels(tunnels);
+    tunnels = [];
+  }
+  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 cleanupTunnels();
+    await env.stop();
+    process.exit(0);
+  }
+  if (args.includes("--reset")) {
+    env.logInfo();
+    await cleanupTunnels();
+    await env.stop({ removeVolumes: true });
+    process.exit(0);
+  }
+  const skipSeed = args.includes("--seed");
+  await env.start({
+    startServers: false,
+    wait: true,
+    skipSeed,
+    skipEnvironmentLog: exposeRequested
+  });
+  if (exposeRequested) {
+    const { targets, unknownNames, notEnabledNames } = resolveExposeTargets(env, exposeValue);
+    if (unknownNames.length > 0) {
+      console.error(`❌ Unknown expose target${unknownNames.length > 1 ? "s" : ""}: ${unknownNames.join(", ")}`);
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    if (notEnabledNames.length > 0) {
+      console.error(`❌ Target${notEnabledNames.length > 1 ? "s" : ""} missing expose: true: ${notEnabledNames.join(", ")}`);
+      console.error("   Mark these in dev.config.ts with expose: true or remove them from --expose.");
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    if (targets.length === 0) {
+      console.error("❌ No expose targets selected. Add expose: true to services/apps or pass names with --expose=<name>.");
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    tunnels = await startPublicTunnels(targets);
+    env.setPublicUrls(Object.fromEntries(tunnels.map((tunnel) => [tunnel.name, tunnel.publicUrl])));
+    env.logInfo("Dev Environment", tunnels);
+  }
+  if (args.includes("--migrate")) {
+    console.log("");
+    console.log("✅ Migrations applied successfully");
+    await cleanupTunnels();
+    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);
+      }
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    console.log("");
+    console.log("✅ Seeding complete");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (args.includes("--up-only")) {
+    console.log("");
+    console.log("✅ Containers started. Environment ready.");
+    console.log("");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (watchdog) {
+    await spawnWatchdog(env.projectName, env.root, {
+      timeoutMinutes: watchdogTimeout,
+      verbose: true,
+      composeFile: env.composeFile
+    });
+    startHeartbeat(env.projectName);
+  }
+  const command = devServersCommand ?? buildDevServersCommand(env.apps);
+  if (!command) {
+    console.log("✅ Containers ready. No apps configured.");
+    await new Promise(() => {});
+    await cleanupTunnels();
+    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(), {
+    onSignal: async () => {
+      await cleanupTunnels();
+      stopHeartbeat();
+    }
+  });
+  stopHeartbeat();
+  await cleanupTunnels();
+}
+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}`;
+}
+function runCommand(command, cwd, envVars, options = {}) {
+  const { onSignal } = options;
+  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 = () => {
+      if (onSignal) {
+        onSignal();
+      }
+      proc.kill("SIGTERM");
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  });
+}
+function hasFlag(args, flag) {
+  return args.some((arg) => arg === flag || arg.startsWith(`${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;
+}
+
+export { runCli, hasFlag, getFlagValue };

package/dist/index-w8zxnjka.js

@@ -0,0 +1,249 @@
+// src/docker-compose/services/define-docker-service.ts
+function defineDockerService(input) {
+	function createPresetDefinition(service) {
+		return {
+			kind: "preset",
+			preset: input.preset,
+			service,
+		};
+	}
+	function toServiceConfig(options = {}) {
+		const base = {
+			port: options.port ?? input.defaults.port,
+			healthCheck: options.healthCheck ?? input.defaults.healthCheck,
+			database: options.database,
+			user: options.user,
+			password: options.password,
+			serviceName: options.serviceName,
+			docker: createPresetDefinition(options.docker),
+		};
+		return input.enhanceServiceConfig
+			? input.enhanceServiceConfig(base, options)
+			: base;
+	}
+	return {
+		preset: input.preset,
+		defaults: input.defaults,
+		build: input.build,
+		createPresetDefinition,
+		toServiceConfig,
+	};
+}
+
+// src/docker-compose/services/shared.ts
+var DEFAULT_HEALTHCHECK_SETTINGS = {
+	interval: "250ms",
+	timeout: "5s",
+	retries: 20,
+};
+function getPortEnvName(portKey) {
+	return `${portKey.toUpperCase()}_PORT`;
+}
+function getDefaultPortBindings(serviceKey, config, preset) {
+	const envName = getPortEnvName(serviceKey);
+	const bindings = [];
+	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;
+}
+function resolveHealthcheck(healthCheck, fallback, options) {
+	if (healthCheck === false) return;
+	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,
+			};
+		case "tcp":
+		default:
+			return fallback;
+	}
+}
+
+// src/docker-compose/services/clickhouse.ts
+var clickhouseDockerService = defineDockerService({
+	preset: "clickhouse",
+	defaults: {
+		port: 8123,
+		secondaryPort: 9000,
+		healthCheck: "http",
+	},
+	enhanceServiceConfig: (base, options) => ({
+		...base,
+		secondaryPort: options.secondaryPort ?? 9000,
+	}),
+	build: ({ serviceKey, config }) => {
+		const user = config.user ?? "default";
+		const password = config.password ?? "clickhouse";
+		const database = config.database ?? "default";
+		const defaultHealthcheck = {
+			test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8123/ping || exit 1"],
+			interval: "250ms",
+			timeout: "5s",
+			retries: 20,
+		};
+		return {
+			service: {
+				image: "clickhouse/clickhouse-server:24-alpine",
+				ports: getDefaultPortBindings(serviceKey, config, "clickhouse"),
+				volumes: [`${serviceKey}_data:/var/lib/clickhouse`],
+				environment: {
+					CLICKHOUSE_USER: user,
+					CLICKHOUSE_PASSWORD: password,
+					CLICKHOUSE_DB: database,
+				},
+				ulimits: {
+					nofile: {
+						soft: 262144,
+						hard: 262144,
+					},
+				},
+				healthcheck: resolveHealthcheck(
+					config.healthCheck,
+					defaultHealthcheck,
+					{
+						internalPort: 8123,
+						user,
+					},
+				),
+			},
+			volume: `${serviceKey}_data`,
+		};
+	},
+});
+
+// src/docker-compose/services/postgres.ts
+var postgresDockerService = defineDockerService({
+	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 = {
+			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`,
+		};
+	},
+});
+
+// src/docker-compose/services/redis.ts
+var redisDockerService = defineDockerService({
+	preset: "redis",
+	defaults: {
+		port: 6379,
+		healthCheck: "redis-cli",
+	},
+	build: ({ serviceKey, config }) => {
+		const defaultHealthcheck = {
+			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,
+					},
+				),
+			},
+		};
+	},
+});
+
+// src/docker-compose/services/index.ts
+var PRESET_SERVICES = {
+	postgres: postgresDockerService,
+	redis: redisDockerService,
+	clickhouse: clickhouseDockerService,
+};
+var service = {
+	postgres: postgresDockerService.toServiceConfig,
+	redis: redisDockerService.toServiceConfig,
+	clickhouse: clickhouseDockerService.toServiceConfig,
+	custom(options) {
+		return options;
+	},
+};
+function inferDockerPreset(serviceKey) {
+	const normalized = serviceKey.toLowerCase();
+	if (Object.hasOwn(PRESET_SERVICES, normalized)) {
+		return normalized;
+	}
+	return;
+}
+function buildPresetDockerService(preset, input) {
+	return PRESET_SERVICES[preset].build(input);
+}
+
+export {
+	getDefaultPortBindings,
+	clickhouseDockerService,
+	postgresDockerService,
+	redisDockerService,
+	service,
+	inferDockerPreset,
+	buildPresetDockerService,
+};