buncargo 1.0.26 → 3.0.0

package/dist/index-23ev345g.js

@@ -0,0 +1,475 @@
+import {
+  areContainersRunning,
+  isContainerRunning,
+  startContainers,
+  startService,
+  stopContainers,
+  waitForServiceByType
+} from "./index-2ckr49sf.js";
+import {
+  getLocalIp,
+  isCI,
+  logExpoApiUrl,
+  logFrontendPort,
+  waitForDevServers,
+  waitForServer
+} from "./index-thdkwnv7.js";
+import {
+  computeDevIdentity,
+  computePorts,
+  computeUrls,
+  findMonorepoRoot
+} from "./index-fb29934k.js";
+import {
+  getGeneratedComposePath,
+  writeGeneratedComposeFile
+} from "./index-5t9jxqm0.js";
+import {
+  logEnvironmentInfo
+} from "./index-bnk6nr0g.js";
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat,
+  stopWatchdog
+} from "./index-mam0bcyz.js";
+import {
+  buildApps,
+  execAsync,
+  startDevServers,
+  stopProcess
+} from "./index-mm412dkp.js";
+import {
+  assertValidConfig
+} from "./index-t0fj6gg1.js";
+
+// src/prisma/prisma.ts
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+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 };
+}
+// src/environment/seeding.ts
+function createCheckTableHelper(urls, exec) {
+  return async (tableName, service) => {
+    const serviceName = service ?? "postgres";
+    const serviceUrl = urls[serviceName];
+    if (!serviceUrl) {
+      console.warn(`⚠️ Service "${serviceName}" not found for checkTable`);
+      return true;
+    }
+    const checkResult = await exec(`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`, { throwOnError: false });
+    const count = checkResult.stdout.trim();
+    const shouldSeed = checkResult.exitCode !== 0 || count === "0" || count === "";
+    if (!shouldSeed) {
+      console.log(`  \uD83D\uDCCA Table "${tableName}" has ${count} rows`);
+    }
+    return shouldSeed;
+  };
+}
+function createSeedCheckContext(baseContext, checkTable) {
+  return {
+    ...baseContext,
+    checkTable
+  };
+}
+
+// src/environment/create-dev-environment.ts
+function createDevEnvironment(config, options = {}) {
+  assertValidConfig(config);
+  const root = findMonorepoRoot();
+  const suffix = options.suffix;
+  const identity = computeDevIdentity({
+    projectPrefix: config.projectPrefix,
+    suffix,
+    root,
+    worktreeIsolation: config.options?.worktreeIsolation
+  });
+  const { worktree, projectSuffix, portOffset, projectName } = identity;
+  const localIp = getLocalIp();
+  const services = config.services;
+  const apps = config.apps ?? {};
+  const composeFile = getGeneratedComposePath(root, config.docker).composeFileArg;
+  function ensureComposeFile() {
+    return writeGeneratedComposeFile(root, services, config.docker);
+  }
+  const ports = computePorts(services, apps, portOffset);
+  const urls = computeUrls(services, apps, ports, localIp);
+  function buildEnvVars(production = false) {
+    const baseEnv = {
+      COMPOSE_PROJECT_NAME: projectName,
+      NODE_ENV: production ? "production" : "development"
+    };
+    for (const [name, port] of Object.entries(ports)) {
+      const envName = `${name.toUpperCase()}_PORT`;
+      baseEnv[envName] = String(port);
+    }
+    for (const [name, url] of Object.entries(urls)) {
+      const envName = `${name.toUpperCase()}_URL`;
+      baseEnv[envName] = url;
+    }
+    if (config.envVars) {
+      const userEnv = config.envVars(ports, urls, {
+        projectName,
+        localIp,
+        portOffset
+      });
+      for (const [key, value] of Object.entries(userEnv)) {
+        baseEnv[key] = String(value);
+      }
+    }
+    return baseEnv;
+  }
+  let hookContext = null;
+  function getHookContext() {
+    if (!hookContext) {
+      hookContext = {
+        projectName,
+        ports,
+        urls,
+        root,
+        isCI: isCI(),
+        portOffset,
+        localIp,
+        exec: async (cmd, opts) => {
+          const envVars = buildEnvVars();
+          return execAsync(cmd, root, envVars, opts);
+        }
+      };
+    }
+    return hookContext;
+  }
+  function exec(cmd, options2) {
+    const envVars = buildEnvVars();
+    return execAsync(cmd, root, envVars, options2);
+  }
+  async function start(startOptions = {}) {
+    const isCI2 = process.env.CI === "true";
+    const {
+      verbose = config.options?.verbose ?? true,
+      wait = true,
+      startServers: shouldStartServers = true,
+      productionBuild = isCI2,
+      skipSeed = false
+    } = startOptions;
+    const envVars = buildEnvVars(productionBuild);
+    ensureComposeFile();
+    if (verbose) {
+      logInfo(productionBuild ? "Production Environment" : "Dev Environment");
+    }
+    const serviceCount = Object.keys(services).length;
+    const alreadyRunning = await areContainersRunning(projectName, serviceCount);
+    if (alreadyRunning) {
+      if (verbose)
+        console.log("✓ Containers already running");
+    } else {
+      startContainers(root, projectName, envVars, {
+        verbose,
+        wait,
+        composeFile
+      });
+    }
+    const allMigrations = [
+      ...config.prisma ? [
+        {
+          name: "prisma",
+          command: "bunx prisma migrate deploy",
+          cwd: config.prisma.cwd ?? "packages/prisma"
+        }
+      ] : [],
+      ...config.migrations ?? []
+    ];
+    if (allMigrations.length > 0) {
+      if (verbose)
+        console.log("\uD83D\uDCE6 Running migrations...");
+      const migrationResults = await Promise.all(allMigrations.map(async (migration) => {
+        const result = await exec(migration.command, {
+          cwd: migration.cwd,
+          throwOnError: false
+        });
+        return { name: migration.name, result };
+      }));
+      for (const { name, result } of migrationResults) {
+        if (result.exitCode !== 0) {
+          console.error(`❌ Migration "${name}" failed`);
+          if (result.stdout) {
+            console.error(result.stdout);
+          }
+          if (result.stderr) {
+            console.error(result.stderr);
+          }
+          throw new Error(`Migration "${name}" failed`);
+        }
+      }
+      if (verbose)
+        console.log("✓ Migrations complete");
+    }
+    if (config.hooks?.afterContainersReady) {
+      await config.hooks.afterContainersReady(getHookContext());
+    }
+    if (config.seed && !skipSeed) {
+      let shouldSeed = true;
+      if (config.seed.check) {
+        const checkTable = createCheckTableHelper(urls, exec);
+        const seedCheckContext = createSeedCheckContext(getHookContext(), checkTable);
+        shouldSeed = await config.seed.check(seedCheckContext);
+      }
+      if (shouldSeed) {
+        if (verbose)
+          console.log("\uD83C\uDF31 Running seeders...");
+        const seedResult = await exec(config.seed.command, {
+          cwd: config.seed.cwd,
+          verbose,
+          throwOnError: false
+        });
+        if (seedResult.exitCode !== 0) {
+          console.error("❌ Seeding failed");
+          console.error(seedResult.stderr);
+        } else {
+          if (verbose)
+            console.log("✓ Seeding complete");
+        }
+      } else {
+        if (verbose)
+          console.log("✓ Database already has data, skipping seeders");
+      }
+    }
+    if (shouldStartServers && Object.keys(apps).length > 0) {
+      if (config.hooks?.beforeServers) {
+        await config.hooks.beforeServers(getHookContext());
+      }
+      if (productionBuild) {
+        buildApps(apps, root, envVars, { verbose });
+      }
+      const pids = await startDevServers(apps, root, envVars, ports, {
+        verbose,
+        productionBuild,
+        isCI: isCI2
+      });
+      if (verbose)
+        console.log("⏳ Waiting for servers to be ready...");
+      await waitForDevServers(apps, ports, {
+        timeout: isCI2 ? 120000 : 60000,
+        verbose,
+        productionBuild
+      });
+      if (config.hooks?.afterServers) {
+        await config.hooks.afterServers(getHookContext());
+      }
+      if (verbose)
+        console.log(`✅ Environment ready
+`);
+      return pids;
+    }
+    if (verbose)
+      console.log(`✅ Containers ready
+`);
+    return null;
+  }
+  async function stop(stopOptions = {}) {
+    const { verbose = true, removeVolumes = false } = stopOptions;
+    ensureComposeFile();
+    if (config.hooks?.beforeStop) {
+      await config.hooks.beforeStop(getHookContext());
+    }
+    stopContainers(root, projectName, {
+      verbose,
+      removeVolumes,
+      composeFile
+    });
+  }
+  async function restart() {
+    await stop();
+    await start({ startServers: false });
+  }
+  async function isRunning() {
+    const serviceCount = Object.keys(services).length;
+    return areContainersRunning(projectName, serviceCount);
+  }
+  async function startServersOnly(options2 = {}) {
+    const { productionBuild = false, verbose = true } = options2;
+    const envVars = buildEnvVars(productionBuild);
+    const isCI2 = process.env.CI === "true";
+    if (productionBuild) {
+      buildApps(apps, root, envVars, { verbose });
+    }
+    return startDevServers(apps, root, envVars, ports, {
+      verbose,
+      productionBuild,
+      isCI: isCI2
+    });
+  }
+  async function waitForServersReady(options2 = {}) {
+    const { timeout = 60000, productionBuild = false } = options2;
+    await waitForDevServers(apps, ports, { timeout, productionBuild });
+  }
+  function logInfo(label = "Docker Dev") {
+    logEnvironmentInfo({
+      label,
+      projectName,
+      services,
+      apps,
+      ports,
+      localIp,
+      worktree,
+      portOffset,
+      projectSuffix
+    });
+  }
+  async function waitForServerUrl(url, timeout) {
+    await waitForServer(url, { timeout });
+  }
+  function startHeartbeat2(intervalMs) {
+    startHeartbeat(projectName, intervalMs);
+  }
+  function stopHeartbeat2() {
+    stopHeartbeat();
+  }
+  async function spawnWatchdog2(timeoutMinutes) {
+    await spawnWatchdog(projectName, root, {
+      timeoutMinutes,
+      verbose: true,
+      composeFile
+    });
+  }
+  function stopWatchdog2() {
+    stopWatchdog(projectName);
+  }
+  function getExpoApiUrl() {
+    const apiPort = ports.api;
+    const url = `http://${localIp}:${apiPort}`;
+    logExpoApiUrl(url);
+    return url;
+  }
+  function getFrontendPort() {
+    const port = ports.platform;
+    logFrontendPort(port);
+    return port;
+  }
+  function withSuffix(newSuffix) {
+    return createDevEnvironment(config, { suffix: newSuffix });
+  }
+  const env = {
+    projectName,
+    ports,
+    urls,
+    services,
+    apps,
+    portOffset,
+    isWorktree: worktree,
+    localIp,
+    root,
+    composeFile,
+    start,
+    stop,
+    restart,
+    isRunning,
+    startServers: startServersOnly,
+    stopProcess,
+    waitForServers: waitForServersReady,
+    buildEnvVars,
+    ensureComposeFile,
+    exec,
+    waitForServer: waitForServerUrl,
+    logInfo,
+    getExpoApiUrl,
+    getFrontendPort,
+    startHeartbeat: startHeartbeat2,
+    stopHeartbeat: stopHeartbeat2,
+    spawnWatchdog: spawnWatchdog2,
+    stopWatchdog: stopWatchdog2,
+    prisma: undefined,
+    withSuffix
+  };
+  if (config.prisma) {
+    env.prisma = createPrismaRunner(env, config.prisma);
+  }
+  return env;
+}
+export { createDevEnvironment };

package/dist/index-2ckr49sf.js

@@ -0,0 +1,228 @@
+import {
+  sleep
+} from "./index-thdkwnv7.js";
+
+// src/docker/runtime.ts
+import { execSync } from "node:child_process";
+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 };