prisma-sharding 0.0.5 → 0.0.7

package/dist/cli/migrate.js

@@ -25,103 +25,360 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/migrate.ts
 var import_config = require("dotenv/config");
+
+// src/utils/env.ts
+var parseBooleanEnv = (name, defaultValue, env = process.env) => {
+  const value = env[name]?.trim();
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+};
+var isVerboseEnv = (names, env = process.env) => names.some((name) => parseBooleanEnv(name, false, env));
+
+// src/cli/utils/output.ts
+var import_readline = __toESM(require("readline"));
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var printCliHeader = (icon, title) => {
+  console.log(`${icon} ${title}
+`);
+};
+var printCliRow = (icon, label, message) => {
+  console.log(`${icon} ${label}  ${message}`);
+};
+var printVerboseHint = () => {
+  console.log("\nRun with SHARD_CLI_VERBOSE=true for details.");
+};
+var createCliLoader = (label, message, enabled = true) => {
+  const animated = enabled && Boolean(process.stdout.isTTY);
+  let frameIndex = 0;
+  let timer;
+  let finished = false;
+  const clear = () => {
+    if (animated) {
+      import_readline.default.clearLine(process.stdout, 0);
+      import_readline.default.cursorTo(process.stdout, 0);
+    }
+  };
+  const render = () => {
+    clear();
+    process.stdout.write(`${SPINNER_FRAMES[frameIndex]} ${label}  ${message}`);
+    frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+  };
+  if (animated) {
+    render();
+    timer = setInterval(render, 80);
+  }
+  const finish = (icon, finalMessage) => {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    if (timer) {
+      clearInterval(timer);
+    }
+    clear();
+    printCliRow(icon, label, finalMessage);
+  };
+  return {
+    succeed: (finalMessage) => finish("\u2705", finalMessage),
+    fail: (finalMessage) => finish("\u274C", finalMessage)
+  };
+};
+
+// src/cli/utils/command.ts
 var import_child_process = require("child_process");
 var import_path = __toESM(require("path"));
-var getShardConfigs = () => {
-  const shards = [];
-  const shardCount = parseInt(process.env.SHARD_COUNT || "0", 10);
-  for (let i = 1; i <= shardCount; i++) {
-    const url = process.env[`SHARD_${i}_URL`];
-    if (url) {
-      shards.push({ id: `shard_${i}`, url });
+
+// src/constants/internal.ts
+var INTERNAL_DEFAULTS = {
+  HEALTH_CHECK_TIMEOUT_MS: 5e3,
+  CROSS_SHARD_CONCURRENCY: 4,
+  CROSS_SHARD_TIMEOUT_MS: 1e4,
+  CLI_COMMAND_TIMEOUT_MS: 12e4,
+  CLI_FORCE_KILL_GRACE_MS: 5e3,
+  CLI_MAX_OUTPUT_LENGTH: 1e6,
+  CLI_TEST_TCP_TIMEOUT_MS: 5e3,
+  CLI_TEST_COMMAND_TIMEOUT_MS: 15e3,
+  STUDIO_BASE_PORT: 51212,
+  STUDIO_REUSE_EXISTING: true,
+  STUDIO_STRICT_PORT_CHECK: false,
+  STUDIO_START_TIMEOUT_MS: 15e3,
+  STUDIO_STABILITY_MS: 500,
+  STUDIO_SHUTDOWN_TIMEOUT_MS: 5e3
+};
+
+// src/utils/sanitize.ts
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var maskDatabaseUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
     }
+    return parsed.toString();
+  } catch {
+    return url.replace(/:[^:@]+@/, ":***@");
   }
-  if (shards.length === 0 && process.env.DATABASE_URL) {
-    shards.push({ id: "shard_1", url: process.env.DATABASE_URL });
+};
+var sanitizeDatabaseText = (output, databaseUrls) => {
+  let sanitized = output;
+  for (const url of databaseUrls) {
+    sanitized = sanitized.replace(new RegExp(escapeRegExp(url), "g"), maskDatabaseUrl(url));
+    try {
+      const password = new URL(url).password;
+      if (password.length >= 4) {
+        sanitized = sanitized.replace(
+          new RegExp(escapeRegExp(decodeURIComponent(password)), "g"),
+          "***"
+        );
+      }
+    } catch {
+    }
+  }
+  return sanitized.replace(
+    /(postgres(?:ql)?:\/\/[^:/\s]+:)[^@\s]+(@)/gi,
+    "$1***$2"
+  );
+};
+
+// src/cli/utils/process.ts
+var isChildProcessRunning = (childProcess) => {
+  return childProcess.exitCode === null && childProcess.signalCode === null;
+};
+var terminateChildProcess = (childProcess, options = {}) => {
+  if (!isChildProcessRunning(childProcess)) {
+    return false;
+  }
+  const signal = options.signal || "SIGTERM";
+  try {
+    if (options.processGroup && childProcess.pid && process.platform !== "win32") {
+      try {
+        process.kill(-childProcess.pid, signal);
+        return true;
+      } catch {
+      }
+    }
+    return childProcess.kill(signal);
+  } catch {
+    return false;
   }
-  return shards;
 };
-var runPrismaCommand = (shardUrl, command) => {
+
+// src/cli/utils/command.ts
+var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+var OUTPUT_TRUNCATED_MARKER = "\n[output truncated]\n";
+var appendBoundedOutput = (current, chunk, limit) => {
+  const combined = current + chunk;
+  if (combined.length <= limit) {
+    return combined;
+  }
+  if (limit <= OUTPUT_TRUNCATED_MARKER.length) {
+    return combined.slice(-limit);
+  }
+  return OUTPUT_TRUNCATED_MARKER + combined.slice(-(limit - OUTPUT_TRUNCATED_MARKER.length));
+};
+var sanitizeCommandOutput = (output, env = process.env) => {
+  const databaseUrls = Object.entries(env).filter(
+    ([name, value]) => Boolean(value) && (name === "DATABASE_URL" || /^SHARD_\d+_URL$/.test(name))
+  ).map(([, value]) => value);
+  return sanitizeDatabaseText(output, databaseUrls).replace(/(\bpassword\s*[=:]\s*)[^\s,;]+/gi, "$1***");
+};
+var runCommand = (command, args, options = {}) => {
   return new Promise((resolve) => {
-    const env = {
-      ...process.env,
-      DATABASE_URL: shardUrl
-    };
-    const prisma = (0, import_child_process.spawn)("npx", ["prisma", ...command], {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let forceKillTimeout;
+    const env = options.env || process.env;
+    const timeoutMs = options.timeoutMs ?? INTERNAL_DEFAULTS.CLI_COMMAND_TIMEOUT_MS;
+    const forceKillGraceMs = options.forceKillGraceMs ?? INTERNAL_DEFAULTS.CLI_FORCE_KILL_GRACE_MS;
+    const maxOutputLength = options.maxOutputLength ?? INTERNAL_DEFAULTS.CLI_MAX_OUTPUT_LENGTH;
+    const processGroup = process.platform !== "win32";
+    const child = (0, import_child_process.spawn)(command, args, {
       env,
-      cwd: import_path.default.resolve(process.cwd()),
-      shell: true
+      cwd: import_path.default.resolve(options.cwd || process.cwd()),
+      detached: processGroup,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    let output = "";
-    let errorOutput = "";
-    prisma.stdout.on("data", (data) => {
-      output += data.toString();
-    });
-    prisma.stderr.on("data", (data) => {
-      errorOutput += data.toString();
+    const settle = (result) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        if (forceKillTimeout) {
+          clearTimeout(forceKillTimeout);
+        }
+        const sanitizedResult = {
+          ...result,
+          stdout: sanitizeCommandOutput(result.stdout, env),
+          stderr: sanitizeCommandOutput(result.stderr, env),
+          error: result.error ? sanitizeCommandOutput(result.error, env) : void 0
+        };
+        if (options.verbose) {
+          if (sanitizedResult.stdout) {
+            process.stdout.write(sanitizedResult.stdout);
+          }
+          if (sanitizedResult.stderr) {
+            process.stderr.write(sanitizedResult.stderr);
+          }
+        }
+        resolve(sanitizedResult);
+      }
+    };
+    child.stdout?.on("data", (data) => {
+      if (!settled) {
+        stdout = appendBoundedOutput(stdout, data.toString(), maxOutputLength);
+      }
     });
-    prisma.on("close", (code) => {
-      if (code === 0) {
-        resolve({ success: true, output });
-      } else {
-        resolve({ success: false, output, error: errorOutput || `Exit code: ${code}` });
+    child.stderr?.on("data", (data) => {
+      if (!settled) {
+        stderr = appendBoundedOutput(stderr, data.toString(), maxOutputLength);
       }
     });
-    prisma.on("error", (err) => {
-      resolve({ success: false, output, error: err.message });
+    child.once("error", (error) => {
+      settle({
+        success: false,
+        stdout,
+        stderr,
+        exitCode: null,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : error.message
+      });
     });
+    child.once("close", (exitCode) => {
+      settle({
+        success: !timedOut && exitCode === 0,
+        stdout,
+        stderr,
+        exitCode,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${exitCode}`
+      });
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminateChildProcess(child, { signal: "SIGTERM", processGroup });
+      forceKillTimeout = setTimeout(() => {
+        terminateChildProcess(child, { signal: "SIGKILL", processGroup });
+        settle({
+          success: false,
+          stdout,
+          stderr,
+          exitCode: null,
+          error: `Command timed out after ${timeoutMs}ms`
+        });
+      }, forceKillGraceMs);
+      forceKillTimeout.unref?.();
+    }, timeoutMs);
+    timeout.unref?.();
   });
 };
-var migrateAllShards = async () => {
-  const shards = getShardConfigs();
-  const extraArgs = process.argv.slice(2);
-  console.log("\u{1F504} prisma-sharding: Starting migrations...\n");
-  console.log(`\u{1F4CA} Total shards to migrate: ${shards.length}`);
-  if (extraArgs.length > 0) {
-    console.log(`\u{1F527} Using flags: ${extraArgs.join(" ")}`);
+var runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
+
+// src/cli/utils/shards.ts
+var NO_SHARDS_CONFIGURED_MESSAGE = "No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables.";
+var getShardConfigResult = (env = process.env) => {
+  const shards = [];
+  const missingShardIds = [];
+  const shardCount = parseInt(env.SHARD_COUNT || "0", 10);
+  for (let i = 1; i <= shardCount; i++) {
+    const url = env[`SHARD_${i}_URL`];
+    if (url) {
+      shards.push({ id: `shard_${i}`, index: i - 1, url });
+    } else {
+      missingShardIds.push(`shard_${i}`);
+    }
   }
-  console.log("");
-  if (shards.length === 0) {
-    console.error(
-      "\u274C No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables."
+  if (shards.length === 0 && env.DATABASE_URL) {
+    shards.push({ id: "shard_1", index: 0, url: env.DATABASE_URL });
+  }
+  return { shards, missingShardIds };
+};
+var maskShardUrl = maskDatabaseUrl;
+
+// src/cli/utils/prisma.ts
+var executeShardCommand = async (shard, commandArgs, verbose, action) => {
+  const commandEnv = { ...process.env, DATABASE_URL: shard.url };
+  if (verbose) {
+    console.log(`
+${action} ${shard.id}...`);
+    console.log(`Database: ${maskShardUrl(shard.url)}
+`);
+    console.log(
+      `Command: ${sanitizeCommandOutput(`prisma ${commandArgs.join(" ")}`, commandEnv)}`
     );
-    process.exit(1);
   }
+  const result = await runPrismaCommand(commandArgs, {
+    env: commandEnv,
+    verbose
+  });
+  if (verbose) {
+    console.log(`Exit code: ${result.exitCode ?? "unavailable"}`);
+  }
+  if (verbose && result.error && !result.stderr.trim() && !result.stdout.trim()) {
+    console.error(result.error);
+  }
+  if (verbose && !result.success) {
+    console.error(`Next: verify ${shard.id} connectivity and migration state, then retry.`);
+  }
+  return result;
+};
+var deployShardMigrations = async (shards, extraArgs, verbose) => {
   const results = [];
   for (const shard of shards) {
-    console.log(`
-\u{1F4E6} Migrating ${shard.id}...`);
-    console.log(`   URL: ${shard.url.replace(/:[^:@]+@/, ":***@")}`);
-    const args = ["db", "push", "--accept-data-loss", ...extraArgs];
-    const { success, output, error } = await runPrismaCommand(shard.url, args);
-    if (!success) {
-      console.error(`   \u274C Failed:`);
-      console.error(error?.replace(/Check logs above/g, "").trim());
-      results.push({ shardId: shard.id, success: false, output, error });
+    const loader = createCliLoader(shard.id, "Migrating", !verbose);
+    const status = await executeShardCommand(
+      shard,
+      ["migrate", "status"],
+      verbose,
+      "Checking migration status for"
+    );
+    if (!status.success) {
+      results.push({ shardId: shard.id, success: false });
+      loader.fail("Failed");
+      continue;
+    }
+    const deploy = await executeShardCommand(
+      shard,
+      ["migrate", "deploy", ...extraArgs],
+      verbose,
+      "Migrating"
+    );
+    results.push({ shardId: shard.id, success: deploy.success });
+    if (deploy.success) {
+      loader.succeed("Synced");
     } else {
-      console.log(`   \u2705 Success`);
-      results.push({ shardId: shard.id, success: true, output });
+      loader.fail("Failed");
     }
   }
-  console.log("\n" + "=".repeat(50));
-  console.log("\u{1F4CB} Migration Summary\n");
-  const successful = results.filter((r) => r.success).length;
-  const failed = results.filter((r) => !r.success).length;
-  results.forEach((result) => {
-    const status = result.success ? "\u2705" : "\u274C";
-    console.log(
-      `   ${status} ${result.shardId}`
-    );
-  });
-  console.log(`
-   Total: ${results.length} | Success: ${successful} | Failed: ${failed}`);
+  return results;
+};
+
+// src/cli/migrate.ts
+var migrateAllShards = async () => {
+  const verbose = isVerboseEnv(["SHARD_MIGRATE_VERBOSE", "SHARD_CLI_VERBOSE"]);
+  const { shards, missingShardIds } = getShardConfigResult();
+  const extraArgs = process.argv.slice(2);
+  printCliHeader("\u{1F504}", "Prisma Sharding Migrate");
+  if (missingShardIds.length > 0) {
+    printCliRow("\u274C", "config", `Missing shard URLs: ${missingShardIds.join(", ")}`);
+    process.exit(1);
+  }
+  if (shards.length === 0) {
+    printCliRow("\u274C", "config", NO_SHARDS_CONFIGURED_MESSAGE);
+    process.exit(1);
+  }
+  const results = await deployShardMigrations(shards, extraArgs, verbose);
+  const successful = results.filter((result) => result.success).length;
+  const failed = results.length - successful;
   if (failed > 0) {
-    console.log("\n\u26A0\uFE0F  Some migrations failed. Run with --force-reset to clear incompatible data.");
+    if (!verbose) {
+      printVerboseHint();
+    }
     process.exit(1);
   }
-  console.log("\n\u2705 All shard migrations completed successfully!");
 };
 migrateAllShards().catch((error) => {
-  console.error("Migration script failed:", error);
+  console.error(error instanceof Error ? error.message : String(error));
   process.exit(1);
 });