buncargo 3.0.0 → 3.2.0

package/dist/index-7v19es2e.js

@@ -0,0 +1,666 @@
+import {
+  areContainersRunning,
+  isContainerRunning,
+  startContainers,
+  startService,
+  stopContainers,
+  waitForServiceByType
+} from "./index-d8tyv5se.js";
+import {
+  getLocalIp,
+  isCI,
+  logExpoApiUrl,
+  logFrontendPort,
+  waitForDevServers,
+  waitForServer
+} from "./index-c0dr6mcv.js";
+import {
+  computeDevIdentity,
+  computePorts,
+  computeUrls,
+  findMonorepoRoot
+} from "./index-fb29934k.js";
+import {
+  getGeneratedComposePath,
+  writeGeneratedComposeFile
+} from "./index-5t9jxqm0.js";
+import {
+  resolveExposeTargets,
+  startPublicTunnels,
+  stopPublicTunnels
+} from "./index-x54nbgs7.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/logging.ts
+import pc from "picocolors";
+function formatUrl(url) {
+  return pc.cyan(url.replace(/:(\d+)(\/?)/, (_, port, slash) => `:${pc.bold(port)}${slash}`));
+}
+function formatLabel(label, value, arrow = "➜") {
+  return `  ${pc.green(arrow)}  ${pc.bold(label.padEnd(10))} ${value}`;
+}
+function formatDimLabel(label, value) {
+  return `  ${pc.dim("•")}  ${pc.dim(label.padEnd(10))} ${pc.dim(value)}`;
+}
+function tunnelFor(tunnels, name, kind) {
+  return tunnels?.find((t) => t.name === name && t.kind === kind);
+}
+function logEnvironmentInfo(input) {
+  const {
+    label,
+    projectName,
+    services,
+    apps,
+    ports,
+    localIp,
+    worktree,
+    portOffset,
+    projectSuffix,
+    tunnels
+  } = input;
+  const serviceNames = Object.keys(services);
+  const appNames = Object.keys(apps);
+  console.log("");
+  console.log(`  ${pc.cyan(pc.bold(`\uD83D\uDC33 ${label}`))}`);
+  console.log(formatLabel("Project:", pc.white(projectName)));
+  if (serviceNames.length > 0) {
+    console.log("");
+    console.log(`  ${pc.dim("─── Services ───")}`);
+    for (const name of serviceNames) {
+      const port = ports[name];
+      const url = `localhost:${port}`;
+      console.log(formatLabel(`${name}:`, formatUrl(`http://${url}`)));
+      const t = tunnelFor(tunnels, name, "service");
+      if (t) {
+        console.log(`       ${pc.dim("Public:")}  ${formatUrl(t.publicUrl)} ${pc.dim("(tunnel)")}`);
+      }
+    }
+  }
+  if (appNames.length > 0) {
+    console.log("");
+    console.log(`  ${pc.dim("─── Applications ───")}`);
+    for (const name of appNames) {
+      const port = ports[name];
+      const localUrl = `http://localhost:${port}`;
+      const networkUrl = `http://${localIp}:${port}`;
+      console.log(`  ${pc.green("➜")}  ${pc.bold(pc.cyan(name))}`);
+      console.log(`       ${pc.dim("Local:")}   ${formatUrl(localUrl)}`);
+      console.log(`       ${pc.dim("Network:")} ${formatUrl(networkUrl)}`);
+      const t = tunnelFor(tunnels, name, "app");
+      if (t) {
+        console.log(`       ${pc.dim("Public:")}  ${formatUrl(t.publicUrl)} ${pc.dim("(tunnel)")}`);
+      }
+    }
+  }
+  console.log("");
+  console.log(`  ${pc.dim("─── Environment ───")}`);
+  console.log(formatDimLabel("Worktree:", worktree ? "yes" : "no"));
+  console.log(formatDimLabel("Port offset:", portOffset > 0 ? `+${portOffset}` : "none"));
+  if (projectSuffix) {
+    console.log(formatDimLabel("Suffix:", projectSuffix));
+  }
+  console.log(formatDimLabel("Local IP:", localIp));
+  console.log("");
+}
+
+// src/environment/only-apps.ts
+function assertOnlyAppNames(appKeys, onlyApps) {
+  if (onlyApps === undefined)
+    return;
+  const unknown = onlyApps.filter((n) => !appKeys.includes(n));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown app name(s) in onlyApps: ${unknown.join(", ")}`);
+  }
+}
+function pickApps(apps, onlyApps) {
+  if (onlyApps === undefined)
+    return apps;
+  const out = {};
+  for (const name of onlyApps) {
+    const config = apps[name];
+    if (config !== undefined) {
+      out[name] = config;
+    }
+  }
+  return out;
+}
+
+// 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);
+  const publicUrls = {};
+  function setPublicUrls(urlsInput) {
+    for (const key of Object.keys(publicUrls)) {
+      delete publicUrls[key];
+    }
+    for (const [key, value] of Object.entries(urlsInput)) {
+      publicUrls[key] = value;
+    }
+  }
+  function clearPublicUrls() {
+    for (const key of Object.keys(publicUrls)) {
+      delete publicUrls[key];
+    }
+  }
+  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;
+    }
+    for (const [name, url] of Object.entries(publicUrls)) {
+      const envName = `${name.toUpperCase()}_PUBLIC_URL`;
+      baseEnv[envName] = url;
+    }
+    if (config.envVars) {
+      const userEnv = config.envVars(ports, urls, {
+        projectName,
+        localIp,
+        portOffset,
+        publicUrls
+      });
+      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,
+        publicUrls,
+        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,
+      skipEnvironmentLog = false,
+      onlyApps
+    } = startOptions;
+    assertOnlyAppNames(Object.keys(apps), onlyApps);
+    const appsToStart = pickApps(apps, onlyApps);
+    const envVars = buildEnvVars(productionBuild);
+    ensureComposeFile();
+    if (verbose && !skipEnvironmentLog) {
+      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(appsToStart).length > 0) {
+      if (config.hooks?.beforeServers) {
+        await config.hooks.beforeServers(getHookContext());
+      }
+      if (productionBuild) {
+        buildApps(appsToStart, root, envVars, { verbose });
+      }
+      const pids = await startDevServers(appsToStart, root, envVars, ports, {
+        verbose,
+        productionBuild,
+        isCI: isCI2
+      });
+      if (verbose)
+        console.log("⏳ Waiting for servers to be ready...");
+      await waitForDevServers(appsToStart, 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, onlyApps } = options2;
+    assertOnlyAppNames(Object.keys(apps), onlyApps);
+    const appsToStart = pickApps(apps, onlyApps);
+    const envVars = buildEnvVars(productionBuild);
+    const isCI2 = process.env.CI === "true";
+    if (Object.keys(appsToStart).length === 0) {
+      return {};
+    }
+    if (productionBuild) {
+      buildApps(appsToStart, root, envVars, { verbose });
+    }
+    const pids = await startDevServers(appsToStart, root, envVars, ports, {
+      verbose,
+      productionBuild,
+      isCI: isCI2
+    });
+    if (verbose)
+      console.log("⏳ Waiting for servers to be ready...");
+    await waitForDevServers(appsToStart, ports, {
+      timeout: isCI2 ? 120000 : 60000,
+      verbose,
+      productionBuild
+    });
+    return pids;
+  }
+  async function waitForServersReady(options2 = {}) {
+    const { timeout = 60000, productionBuild = false, onlyApps } = options2;
+    assertOnlyAppNames(Object.keys(apps), onlyApps);
+    const appsToWait = pickApps(apps, onlyApps);
+    await waitForDevServers(appsToWait, ports, { timeout, productionBuild });
+  }
+  async function openPublicTunnels(options2 = {}) {
+    const { names, waitForHealthy } = options2;
+    const exposeList = names?.length ? names.join(",") : undefined;
+    if (waitForHealthy?.length) {
+      assertOnlyAppNames(Object.keys(apps), waitForHealthy);
+      const appsWait = pickApps(apps, waitForHealthy);
+      const isCI2 = process.env.CI === "true";
+      await waitForDevServers(appsWait, ports, {
+        timeout: isCI2 ? 120000 : 60000,
+        verbose: config.options?.verbose ?? true,
+        productionBuild: false
+      });
+    }
+    const { targets, unknownNames, notEnabledNames } = resolveExposeTargets({
+      services,
+      apps,
+      ports
+    }, exposeList);
+    if (unknownNames.length > 0) {
+      throw new Error(`Unknown expose target(s): ${unknownNames.join(", ")}`);
+    }
+    if (notEnabledNames.length > 0) {
+      throw new Error(`Target(s) missing expose: true: ${notEnabledNames.join(", ")}`);
+    }
+    if (targets.length === 0) {
+      throw new Error("No expose targets selected. Add expose: true to services/apps or pass names that have expose: true.");
+    }
+    const tunnels = await startPublicTunnels(targets);
+    setPublicUrls(Object.fromEntries(tunnels.map((t) => [t.name, t.publicUrl])));
+    let closed = false;
+    async function close() {
+      if (closed)
+        return;
+      closed = true;
+      await stopPublicTunnels(tunnels);
+      clearPublicUrls();
+    }
+    return {
+      publicUrls: { ...publicUrls },
+      tunnels,
+      close
+    };
+  }
+  function logInfo(label = "Docker Dev", tunnels) {
+    const tunnelRows = tunnels?.map(({ kind, name, localUrl, publicUrl }) => ({
+      kind,
+      name,
+      localUrl,
+      publicUrl
+    }));
+    logEnvironmentInfo({
+      label,
+      projectName,
+      services,
+      apps,
+      ports,
+      localIp,
+      worktree,
+      portOffset,
+      projectSuffix,
+      tunnels: tunnelRows
+    });
+  }
+  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,
+    publicUrls,
+    services,
+    apps,
+    portOffset,
+    isWorktree: worktree,
+    localIp,
+    root,
+    composeFile,
+    start,
+    stop,
+    restart,
+    isRunning,
+    startServers: startServersOnly,
+    stopProcess,
+    waitForServers: waitForServersReady,
+    buildEnvVars,
+    setPublicUrls: (urlsInput) => {
+      setPublicUrls(urlsInput);
+    },
+    clearPublicUrls,
+    ensureComposeFile,
+    exec,
+    waitForServer: waitForServerUrl,
+    logInfo,
+    openPublicTunnels,
+    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 };