prisma-sharding 0.0.6 → 0.0.7

package/dist/cli/update.js

@@ -39,36 +39,152 @@ var isVerboseEnv = (names, env = process.env) => names.some((name) => parseBoole
 // src/cli/utils/command.ts
 var import_child_process = require("child_process");
 var import_path = __toESM(require("path"));
+
+// 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(/:[^:@]+@/, ":***@");
+  }
+};
+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;
+  }
+};
+
+// 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) => {
     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: options.env || process.env,
+      env,
       cwd: import_path.default.resolve(options.cwd || process.cwd()),
+      detached: processGroup,
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
     const settle = (result) => {
       if (!settled) {
         settled = true;
-        resolve(result);
+        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) => {
-      const output = data.toString();
-      stdout += output;
-      if (options.verbose) {
-        process.stdout.write(output);
+      if (!settled) {
+        stdout = appendBoundedOutput(stdout, data.toString(), maxOutputLength);
       }
     });
     child.stderr?.on("data", (data) => {
-      const output = data.toString();
-      stderr += output;
-      if (options.verbose) {
-        process.stderr.write(output);
+      if (!settled) {
+        stderr = appendBoundedOutput(stderr, data.toString(), maxOutputLength);
       }
     });
     child.once("error", (error) => {
@@ -76,18 +192,35 @@ var runCommand = (command, args, options = {}) => {
         success: false,
         stdout,
         stderr,
-        error: error.message
+        exitCode: null,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : error.message
       });
     });
     child.once("close", (exitCode) => {
       settle({
-        success: exitCode === 0,
+        success: !timedOut && exitCode === 0,
         stdout,
         stderr,
         exitCode,
-        error: exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${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 runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
@@ -161,42 +294,47 @@ var getShardConfigResult = (env = process.env) => {
   }
   return { shards, missingShardIds };
 };
-var getShardConfigs = (env = process.env) => {
-  return getShardConfigResult(env).shards;
-};
-var maskShardUrl = (url) => {
-  try {
-    const parsed = new URL(url);
-    if (parsed.password) {
-      parsed.password = "***";
-    }
-    return parsed.toString();
-  } catch {
-    return url.replace(/:[^:@]+@/, ":***@");
-  }
-};
+var maskShardUrl = maskDatabaseUrl;
 
 // src/cli/utils/prisma.ts
-var syncShardSchemas = async (shards, extraArgs, verbose) => {
-  const results = [];
-  for (const shard of shards) {
-    const loader = createCliLoader(shard.id, "Syncing", !verbose);
-    if (verbose) {
-      console.log(`
-Syncing ${shard.id}...`);
-      console.log(`Database: ${maskShardUrl(shard.url)}
+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)}
 `);
-    }
-    const result = await runPrismaCommand(
-      ["db", "push", "--accept-data-loss", ...extraArgs],
-      {
-        env: { ...process.env, DATABASE_URL: shard.url },
-        verbose
-      }
+    console.log(
+      `Command: ${sanitizeCommandOutput(`prisma ${commandArgs.join(" ")}`, commandEnv)}`
     );
-    if (verbose && result.error && !result.stderr.trim() && !result.stdout.trim()) {
-      console.error(result.error);
-    }
+  }
+  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 runShardCommands = async ({
+  shards,
+  args,
+  extraArgs,
+  verbose,
+  action
+}) => {
+  const results = [];
+  for (const shard of shards) {
+    const loader = createCliLoader(shard.id, action, !verbose);
+    const commandArgs = [...args, ...extraArgs];
+    const result = await executeShardCommand(shard, commandArgs, verbose, action);
     results.push({ shardId: shard.id, success: result.success });
     if (result.success) {
       loader.succeed("Synced");
@@ -206,13 +344,24 @@ Syncing ${shard.id}...`);
   }
   return results;
 };
+var syncShardSchemas = (shards, extraArgs, verbose) => runShardCommands({
+  shards,
+  args: ["db", "push"],
+  extraArgs,
+  verbose,
+  action: "Syncing"
+});
 
 // src/cli/update.ts
 var updateAll = async () => {
   const verbose = isVerboseEnv(["SHARD_UPDATE_VERBOSE", "SHARD_CLI_VERBOSE"]);
-  const shards = getShardConfigs();
+  const { shards, missingShardIds } = getShardConfigResult();
   const extraArgs = process.argv.slice(2);
   printCliHeader("\u{1F504}", "Prisma Sharding Update");
+  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);

package/dist/cli/utils/command.js

@@ -0,0 +1,232 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/utils/command.ts
+var command_exports = {};
+__export(command_exports, {
+  getNpxCommand: () => getNpxCommand,
+  runCommand: () => runCommand,
+  runPrismaCommand: () => runPrismaCommand,
+  sanitizeCommandOutput: () => sanitizeCommandOutput
+});
+module.exports = __toCommonJS(command_exports);
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
+
+// 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(/:[^:@]+@/, ":***@");
+  }
+};
+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;
+  }
+};
+
+// 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) => {
+    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(options.cwd || process.cwd()),
+      detached: processGroup,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    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);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (!settled) {
+        stderr = appendBoundedOutput(stderr, data.toString(), maxOutputLength);
+      }
+    });
+    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 runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNpxCommand,
+  runCommand,
+  runPrismaCommand,
+  sanitizeCommandOutput
+});

package/dist/cli/utils/postgres.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/utils/postgres.ts
+var postgres_exports = {};
+__export(postgres_exports, {
+  parsePostgresUrl: () => parsePostgresUrl,
+  postgresEndpoint: () => postgresEndpoint
+});
+module.exports = __toCommonJS(postgres_exports);
+var parsePostgresUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "postgresql:" && parsed.protocol !== "postgres:") {
+      return null;
+    }
+    const database = decodeURIComponent(parsed.pathname.replace(/^\/+/, ""));
+    const port = parsed.port ? Number(parsed.port) : 5432;
+    const queryHost = parsed.searchParams.get("host");
+    const host = parsed.hostname.replace(/^\[(.*)\]$/, "$1");
+    if (!database || !host || !Number.isInteger(port) || port <= 0 || port > 65535) {
+      return null;
+    }
+    return {
+      host,
+      port,
+      database,
+      socketPath: queryHost?.startsWith("/") ? queryHost : void 0
+    };
+  } catch {
+    return null;
+  }
+};
+var postgresEndpoint = (info) => info.socketPath || `${info.host}:${info.port}`;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePostgresUrl,
+  postgresEndpoint
+});