buncargo 1.0.29 → 3.0.0

package/dist/index-etfmqjjf.js

@@ -0,0 +1,427 @@
+// 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,
+      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-fb29934k.js

@@ -0,0 +1,172 @@
+// src/core/ports.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+function findMonorepoRoot(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (dir !== "/") {
+    try {
+      const pkgPath = resolve(dir, "package.json");
+      if (existsSync(pkgPath)) {
+        const content = readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (pkg.workspaces) {
+          return dir;
+        }
+      }
+    } catch {}
+    dir = dirname(dir);
+  }
+  return process.cwd();
+}
+function getWorktreeName(root) {
+  const monorepoRoot = root ?? findMonorepoRoot();
+  const gitPath = resolve(monorepoRoot, ".git");
+  try {
+    if (!existsSync(gitPath) || !statSync(gitPath).isFile())
+      return null;
+    const content = readFileSync(gitPath, "utf-8").trim();
+    const match = content.match(/^gitdir:\s*(.+)$/);
+    if (!match?.[1])
+      return null;
+    return basename(match[1]);
+  } catch {
+    return null;
+  }
+}
+function isWorktree(root) {
+  return getWorktreeName(root) !== null;
+}
+function sanitizeProjectSuffix(value) {
+  return value.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function getWorktreeProjectSuffix(root) {
+  const worktreeName = getWorktreeName(root);
+  if (!worktreeName)
+    return null;
+  const sanitized = sanitizeProjectSuffix(worktreeName);
+  return sanitized || "worktree";
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function calculatePortOffset(suffix, root) {
+  const worktreeName = getWorktreeName(root);
+  if (!worktreeName)
+    return 0;
+  const hashInput = suffix ? `${worktreeName}-${suffix}` : worktreeName;
+  return 10 + simpleHash(hashInput) % 90;
+}
+function getProjectName(prefix, suffix, root) {
+  const monorepoRoot = root ?? findMonorepoRoot();
+  const dirName = basename(monorepoRoot);
+  const baseName = `${prefix}-${dirName.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+  return suffix ? `${baseName}-${suffix}` : baseName;
+}
+function computeDevIdentity(options) {
+  const {
+    projectPrefix,
+    suffix,
+    root: providedRoot,
+    worktreeIsolation = true
+  } = options;
+  const root = providedRoot ?? findMonorepoRoot();
+  const worktree = isWorktree(root);
+  const worktreeSuffix = worktree && worktreeIsolation ? getWorktreeProjectSuffix(root) : null;
+  const projectSuffix = [suffix, worktreeSuffix].filter(Boolean).join("-") || undefined;
+  const projectName = getProjectName(projectPrefix, projectSuffix, root);
+  const portOffset = calculatePortOffset(suffix, root);
+  return {
+    worktree,
+    worktreeSuffix,
+    projectSuffix,
+    projectName,
+    portOffset
+  };
+}
+function computePorts(services, apps, offset) {
+  const ports = {};
+  for (const [name, config] of Object.entries(services)) {
+    ports[name] = config.port + offset;
+    if (config.secondaryPort) {
+      ports[`${name}Secondary`] = config.secondaryPort + offset;
+    }
+  }
+  if (apps) {
+    for (const [name, config] of Object.entries(apps)) {
+      ports[name] = config.port + offset;
+    }
+  }
+  return ports;
+}
+var SERVICE_DEFAULTS = {
+  postgres: { user: "postgres", password: "postgres", database: "postgres" },
+  postgresql: { user: "postgres", password: "postgres", database: "postgres" },
+  redis: { user: "", password: "", database: "" },
+  clickhouse: { user: "default", password: "clickhouse", database: "default" },
+  mysql: { user: "root", password: "root", database: "mysql" },
+  mongodb: { user: "", password: "", database: "" }
+};
+function buildServiceUrl(serviceName, ctx, config) {
+  const defaults = SERVICE_DEFAULTS[serviceName];
+  if (!defaults && !config.database)
+    return null;
+  const user = config.user ?? defaults?.user ?? "";
+  const password = config.password ?? defaults?.password ?? "";
+  const database = config.database ?? defaults?.database ?? "";
+  switch (serviceName) {
+    case "postgres":
+    case "postgresql":
+      return `postgresql://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
+    case "redis":
+      return `redis://${ctx.host}:${ctx.port}`;
+    case "clickhouse":
+      return `http://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
+    case "mysql":
+      return `mysql://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
+    case "mongodb":
+      return database ? `mongodb://${ctx.host}:${ctx.port}/${database}` : `mongodb://${ctx.host}:${ctx.port}`;
+    default:
+      return null;
+  }
+}
+function computeUrls(services, apps, ports, localIp) {
+  const urls = {};
+  const host = "localhost";
+  for (const [name, config] of Object.entries(services)) {
+    const port = ports[name];
+    const secondaryPort = ports[`${name}Secondary`];
+    if (port === undefined)
+      continue;
+    const ctx = { port, secondaryPort, host, localIp };
+    if (config.urlTemplate) {
+      urls[name] = config.urlTemplate(ctx);
+    } else {
+      const builtUrl = buildServiceUrl(name, { port, host }, {
+        database: config.database,
+        user: config.user,
+        password: config.password
+      });
+      if (builtUrl) {
+        urls[name] = builtUrl;
+      } else {
+        urls[name] = `http://${host}:${port}`;
+      }
+    }
+  }
+  if (apps) {
+    for (const [name, _config] of Object.entries(apps)) {
+      const port = ports[name];
+      urls[name] = `http://${host}:${port}`;
+      urls[`${name}Local`] = `http://${localIp}:${port}`;
+    }
+  }
+  return urls;
+}
+
+export { findMonorepoRoot, getWorktreeName, isWorktree, getWorktreeProjectSuffix, calculatePortOffset, getProjectName, computeDevIdentity, computePorts, computeUrls };

package/dist/index-g50jw1yf.js

@@ -0,0 +1,72 @@
+import {
+  createDevEnvironment
+} from "./index-8bw1cmz4.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 };