buncargo 1.0.29 → 3.2.0

package/dist/index-5t9jxqm0.js

@@ -0,0 +1,428 @@
+// src/docker-compose/generated-file.ts
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+
+// 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,
+      expose: options.expose,
+      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
+      };
+    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);
+}
+
+// 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, service2) {
+  const normalized = { ...service2 };
+  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: service2, volume } = buildPresetDockerService(normalized.preset, {
+    serviceKey: name,
+    config
+  });
+  const mergedService = normalized.serviceOverride ? deepMergeNode(service2, normalized.serviceOverride) : service2;
+  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: service2, volume } = resolveServiceDefinition(name, serviceConfig);
+    composeServices[serviceName] = service2;
+    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 { service, buildComposeModel, composeToYaml, DEFAULT_GENERATED_COMPOSE_FILE, getGeneratedComposePath, writeGeneratedComposeFile };

package/dist/index-6c1w1xk5.js

@@ -0,0 +1,101 @@
+// src/prisma/prisma.ts
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import {
+	isContainerRunning,
+	startService,
+	waitForServiceByType,
+} from "./index-tjbx2r2t.js";
+
+function createPrismaRunner(env, config) {
+	const {
+		cwd = "packages/prisma",
+		service = "postgres",
+		urlEnvVar = "DATABASE_URL",
+	} = config;
+	const healthCheckTypes = {
+		postgres: "pg_isready",
+		redis: "redis-cli",
+		clickhouse: "http",
+	};
+	function getDatabaseUrl() {
+		const envVars = env.buildEnvVars();
+		const url = envVars[urlEnvVar];
+		if (!url) {
+			throw new Error(
+				`Environment variable ${urlEnvVar} not found. Make sure your dev config defines it in envVars.`,
+			);
+		}
+		return url;
+	}
+	async function ensureDatabase() {
+		const alreadyRunning = await isContainerRunning(env.projectName, service);
+		if (alreadyRunning) {
+			console.log(`✓ ${service} already running`);
+			return;
+		}
+		console.log(`\uD83D\uDC33 Starting ${service}...`);
+		const composeFile = env.ensureComposeFile();
+		const envVars = env.buildEnvVars();
+		startService(env.root, env.projectName, service, envVars, {
+			verbose: false,
+			composeFile,
+		});
+		const port = env.ports[service];
+		if (!port) {
+			throw new Error(`Service ${service} not found in dev environment ports`);
+		}
+		const healthCheckType = healthCheckTypes[service] ?? "tcp";
+		console.log(`⏳ Waiting for ${service} to be healthy...`);
+		await waitForServiceByType(service, healthCheckType, port, {
+			verbose: true,
+		});
+	}
+	async function run(args) {
+		if (args.length === 0) {
+			console.log(`
+Usage: bun prisma <command> [args...]
+
+Examples:
+  bun prisma migrate dev     # Create new migration
+  bun prisma migrate deploy  # Apply migrations
+  bun prisma db push         # Push schema changes
+  bun prisma studio          # Open Prisma Studio
+  bun prisma migrate reset   # Reset database
+`);
+			return 0;
+		}
+		const port = env.ports[service];
+		console.log(`
+\uD83D\uDD27 Prisma CLI
+   Project: ${env.projectName}
+   Database: localhost:${port}
+   ${env.portOffset > 0 ? `(port offset +${env.portOffset})` : ""}
+`);
+		await ensureDatabase();
+		const envVars = env.buildEnvVars();
+		const workingDir = join(env.root, cwd);
+		const fullEnv = {
+			...process.env,
+			...envVars,
+			[urlEnvVar]: getDatabaseUrl(),
+		};
+		console.log(`\uD83D\uDD04 Running: prisma ${args.join(" ")}
+`);
+		return new Promise((resolve) => {
+			const proc = spawn("bunx", ["prisma", ...args], {
+				cwd: workingDir,
+				env: fullEnv,
+				stdio: "inherit",
+			});
+			proc.on("close", (code) => {
+				resolve(code ?? 0);
+			});
+			proc.on("error", () => {
+				resolve(1);
+			});
+		});
+	}
+	return { run, getDatabaseUrl, ensureDatabase };
+}
+export { createPrismaRunner };

package/dist/index-6cmex7m5.js

@@ -0,0 +1,72 @@
+import {
+  createDevEnvironment
+} from "./index-qa8akv6y.js";
+
+// src/loader/cache.ts
+var cachedEnv = null;
+function setCachedDevEnv(env) {
+  cachedEnv = env;
+}
+function getCachedDevEnv() {
+  return cachedEnv;
+}
+function clearDevEnvCache() {
+  cachedEnv = null;
+}
+// src/loader/find-config-file.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+var CONFIG_FILES = [
+  "dev.config.ts",
+  "dev.config.js",
+  "dev-tools.config.ts",
+  "dev-tools.config.js"
+];
+function findConfigFile(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    for (const file of CONFIG_FILES) {
+      const configPath = join(currentDir, file);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+// src/loader/load-dev-env.ts
+async function loadDevEnv(options) {
+  if (!options?.reload) {
+    const cached = getCachedDevEnv();
+    if (cached)
+      return cached;
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const configPath = findConfigFile(cwd);
+  if (configPath) {
+    const mod = await import(configPath);
+    const config = mod.default;
+    if (!config?.projectPrefix || !config?.services) {
+      throw new Error(`Invalid config in "${configPath}". Use defineDevConfig() and export as default.`);
+    }
+    const env = createDevEnvironment(config);
+    setCachedDevEnv(env);
+    return env;
+  }
+  throw new Error("No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })");
+}
+
+// src/loader/index.ts
+function getDevEnv() {
+  const env = getCachedDevEnv();
+  if (!env) {
+    throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+  }
+  return env;
+}
+
+export { clearDevEnvCache, CONFIG_FILES, findConfigFile, loadDevEnv, getDevEnv };