prisma-sharding 0.0.6 → 0.0.7

package/dist/cli/studio.js

@@ -25,28 +25,116 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/studio.ts
 var import_config = require("dotenv/config");
+
+// src/cli/utils/studio-runner.ts
 var import_child_process = require("child_process");
 
-// src/utils/env.ts
-var parseBooleanEnv = (name, defaultValue, env = process.env) => {
-  const value = env[name]?.trim();
-  if (value === void 0 || value === "") {
-    return defaultValue;
+// 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(/:[^:@]+@/, ":***@");
   }
-  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
 };
-var parsePositiveIntegerEnv = (name, defaultValue, env = process.env) => {
-  const value = env[name]?.trim();
-  if (!value) {
-    return defaultValue;
+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 {
+    }
   }
-  const parsed = parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue;
+  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;
+  }
+};
+var waitForChildProcessClose = (childProcess, timeoutMs) => {
+  return new Promise((resolve) => {
+    if (!isChildProcessRunning(childProcess)) {
+      resolve(true);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve(false);
+    }, timeoutMs);
+    const onClose = () => {
+      clearTimeout(timeout);
+      cleanup();
+      resolve(true);
+    };
+    const cleanup = () => {
+      childProcess.off("close", onClose);
+      childProcess.off("exit", onClose);
+    };
+    childProcess.once("close", onClose);
+    childProcess.once("exit", onClose);
+  });
 };
-var isVerboseEnv = (names, env = process.env) => names.some((name) => parseBooleanEnv(name, false, env));
 
 // src/cli/utils/command.ts
 var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+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***");
+};
 
 // src/cli/utils/ports.ts
 var import_http = __toESM(require("http"));
@@ -205,52 +293,6 @@ var waitForPrismaStudio = async (port, timeoutMs, intervalMs = 400, shouldContin
   return lastProbe;
 };
 
-// src/cli/utils/process.ts
-var isChildProcessRunning = (childProcess) => {
-  return childProcess.exitCode === null && childProcess.signalCode === null && !childProcess.killed;
-};
-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;
-  }
-};
-var waitForChildProcessClose = (childProcess, timeoutMs) => {
-  return new Promise((resolve) => {
-    if (!isChildProcessRunning(childProcess)) {
-      resolve(true);
-      return;
-    }
-    const timeout = setTimeout(() => {
-      cleanup();
-      resolve(false);
-    }, timeoutMs);
-    const onClose = () => {
-      clearTimeout(timeout);
-      cleanup();
-      resolve(true);
-    };
-    const cleanup = () => {
-      childProcess.off("close", onClose);
-      childProcess.off("exit", onClose);
-    };
-    childProcess.once("close", onClose);
-    childProcess.once("exit", onClose);
-  });
-};
-
 // 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) => {
@@ -270,34 +312,60 @@ var getShardConfigResult = (env = process.env) => {
   }
   return { shards, missingShardIds };
 };
-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/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 parsePositiveIntegerEnv = (name, defaultValue, env = process.env) => {
+  const value = env[name]?.trim();
+  if (!value) {
+    return defaultValue;
   }
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue;
 };
+var isVerboseEnv = (names, env = process.env) => names.some((name) => parseBooleanEnv(name, false, env));
 
-// src/cli/studio.ts
+// src/cli/utils/studio-options.ts
+var getStudioOptions = () => ({
+  basePort: parsePositiveIntegerEnv(
+    "SHARD_STUDIO_BASE_PORT",
+    INTERNAL_DEFAULTS.STUDIO_BASE_PORT
+  ),
+  reuseExisting: parseBooleanEnv(
+    "SHARD_STUDIO_REUSE_EXISTING",
+    INTERNAL_DEFAULTS.STUDIO_REUSE_EXISTING
+  ),
+  startupTimeoutMs: parsePositiveIntegerEnv(
+    "SHARD_STUDIO_START_TIMEOUT_MS",
+    INTERNAL_DEFAULTS.STUDIO_START_TIMEOUT_MS
+  ),
+  stabilityMs: parsePositiveIntegerEnv(
+    "SHARD_STUDIO_STABILITY_MS",
+    INTERNAL_DEFAULTS.STUDIO_STABILITY_MS
+  ),
+  shutdownTimeoutMs: parsePositiveIntegerEnv(
+    "SHARD_STUDIO_SHUTDOWN_TIMEOUT_MS",
+    INTERNAL_DEFAULTS.STUDIO_SHUTDOWN_TIMEOUT_MS
+  ),
+  strictPortCheck: parseBooleanEnv(
+    "SHARD_STUDIO_STRICT_PORT_CHECK",
+    INTERNAL_DEFAULTS.STUDIO_STRICT_PORT_CHECK
+  ),
+  verbose: isVerboseEnv(["SHARD_STUDIO_VERBOSE", "SHARD_STUDIO_DEBUG"])
+});
+
+// src/cli/utils/studio-runner.ts
 var instances = [];
 var activeOptions;
 var isShuttingDown = false;
 var keepAliveTimer;
-var getStudioOptions = () => {
-  return {
-    basePort: parsePositiveIntegerEnv("SHARD_STUDIO_BASE_PORT", 51212),
-    reuseExisting: parseBooleanEnv("SHARD_STUDIO_REUSE_EXISTING", true),
-    startupTimeoutMs: parsePositiveIntegerEnv("SHARD_STUDIO_START_TIMEOUT_MS", 15e3),
-    stabilityMs: parsePositiveIntegerEnv("SHARD_STUDIO_STABILITY_MS", 500),
-    shutdownTimeoutMs: parsePositiveIntegerEnv("SHARD_STUDIO_SHUTDOWN_TIMEOUT_MS", 5e3),
-    strictPortCheck: parseBooleanEnv("SHARD_STUDIO_STRICT_PORT_CHECK", false),
-    verbose: isVerboseEnv(["SHARD_STUDIO_VERBOSE", "SHARD_STUDIO_DEBUG"])
-  };
-};
 var studioUrl = (port) => `http://localhost:${port}`;
 var isAddressInUseOutput = (output) => output.includes("EADDRINUSE");
 var outputLooksReady = (output, port) => {
@@ -309,11 +377,11 @@ var logVerbose = (options, message, writer = console.log) => {
     writer(message);
   }
 };
-var writeVerboseOutput = (options, shardId, output, writer) => {
+var writeVerboseOutput = (options, shardId, shardUrl, output, writer) => {
   if (!options.verbose) {
     return;
   }
-  output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).forEach((line) => writer(`   [${shardId}] ${line}`));
+  sanitizeCommandOutput(output, { DATABASE_URL: shardUrl }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).forEach((line) => writer(`   [${shardId}] ${line}`));
 };
 var failedInstance = (shard, port, message, details, severity = "error") => {
   return {
@@ -429,7 +497,7 @@ var startSpawnedStudio = (shard, port, options) => {
       if (outputLooksReady(output, port)) {
         settleStartedAfterStability();
       }
-      writeVerboseOutput(options, shardId, output, console.log);
+      writeVerboseOutput(options, shardId, shard.url, output, console.log);
     });
     studioProcess.stderr?.on("data", (data) => {
       const output = data.toString();
@@ -438,7 +506,7 @@ var startSpawnedStudio = (shard, port, options) => {
         addressInUse = true;
         return;
       }
-      writeVerboseOutput(options, shardId, output, console.error);
+      writeVerboseOutput(options, shardId, shard.url, output, console.error);
     });
     studioProcess.on("error", (err) => {
       fail("Failed to start", err.message);

package/dist/cli/test.js

@@ -26,6 +26,92 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli/test.ts
 var import_config = require("dotenv/config");
 
+// 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/command.ts
+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***");
+};
+
+// src/cli/utils/postgres.ts
+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}`;
+
 // 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) => {
@@ -45,9 +131,6 @@ var getShardConfigResult = (env = process.env) => {
   }
   return { shards, missingShardIds };
 };
-var getShardConfigs = (env = process.env) => {
-  return getShardConfigResult(env).shards;
-};
 
 // src/cli/test.ts
 var results = [];
@@ -78,28 +161,11 @@ var runTest = async (name, testFn) => {
     log.error(`${name}: ${message}`);
   }
 };
-var parsePostgresUrl = (url) => {
-  try {
-    const match = url.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)/);
-    if (match) {
-      return {
-        user: match[1],
-        password: match[2],
-        host: match[3],
-        port: parseInt(match[4], 10),
-        database: match[5]
-      };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-};
-var testTcpConnection = (host, port) => {
+var testTcpConnection = (urlInfo) => {
   return new Promise((resolve) => {
     import("net").then(({ default: net }) => {
       const socket = new net.Socket();
-      socket.setTimeout(5e3);
+      socket.setTimeout(INTERNAL_DEFAULTS.CLI_TEST_TCP_TIMEOUT_MS);
       socket.on("connect", () => {
         socket.destroy();
         resolve(true);
@@ -112,7 +178,11 @@ var testTcpConnection = (host, port) => {
         socket.destroy();
         resolve(false);
       });
-      socket.connect(port, host);
+      if (urlInfo.socketPath) {
+        socket.connect(`${urlInfo.socketPath}/.s.PGSQL.${urlInfo.port}`);
+      } else {
+        socket.connect(urlInfo.port, urlInfo.host);
+      }
     }).catch(() => resolve(false));
   });
 };
@@ -124,15 +194,19 @@ var getPgClient = async () => {
     return null;
   }
 };
-var executeSql = async (url, sql) => {
+var executeSql = async (url, statement) => {
   const Client = await getPgClient();
+  const normalized = typeof statement === "string" ? { text: statement } : statement;
   if (!Client) {
-    return executeSqlWithPsql(url, sql);
+    if (normalized.values && !normalized.psqlText) {
+      return { success: false, error: "Parameterized SQL has no safe psql fallback" };
+    }
+    return executeSqlWithPsql(url, normalized.psqlText ?? normalized.text);
   }
   const client = new Client({ connectionString: url });
   try {
     await client.connect();
-    const result = await client.query(sql);
+    const result = await client.query(normalized.text, normalized.values);
     await client.end();
     return { success: true, rows: result.rows };
   } catch (error) {
@@ -140,14 +214,18 @@ var executeSql = async (url, sql) => {
       await client.end();
     } catch {
     }
-    return { success: false, error: error instanceof Error ? error.message : String(error) };
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: sanitizeCommandOutput(message, { DATABASE_URL: url })
+    };
   }
 };
 var executeSqlWithPsql = (url, sql) => {
   return new Promise((resolve) => {
     import("child_process").then(({ spawn }) => {
       const psql = spawn("psql", [url, "-c", sql], {
-        shell: true,
+        shell: false,
         stdio: ["pipe", "pipe", "pipe"]
       });
       let stderr = "";
@@ -157,14 +235,21 @@ var executeSqlWithPsql = (url, sql) => {
       const timeout = setTimeout(() => {
         psql.kill();
         resolve({ success: false, error: "Command timeout" });
-      }, 15e3);
+      }, INTERNAL_DEFAULTS.CLI_TEST_COMMAND_TIMEOUT_MS);
+      timeout.unref?.();
       psql.on("close", (code) => {
         clearTimeout(timeout);
-        resolve({ success: code === 0, error: code !== 0 ? stderr : void 0 });
+        resolve({
+          success: code === 0,
+          error: code !== 0 ? sanitizeCommandOutput(stderr, { DATABASE_URL: url }) : void 0
+        });
       });
       psql.on("error", (err) => {
         clearTimeout(timeout);
-        resolve({ success: false, error: err.message });
+        resolve({
+          success: false,
+          error: sanitizeCommandOutput(err.message, { DATABASE_URL: url })
+        });
       });
     });
   });
@@ -182,7 +267,7 @@ var getShardIndex = (key, shardCount) => {
   return hashString(key) % shardCount;
 };
 var runTests = async () => {
-  const shards = getShardConfigs();
+  const { shards, missingShardIds } = getShardConfigResult();
   const timestamp = Date.now();
   const testTableName = `_prisma_sharding_test_${timestamp}`;
   console.log("\n" + "\u2550".repeat(60));
@@ -194,6 +279,11 @@ var runTests = async () => {
   console.log(`   \u2022 Routing Strategy: ${process.env.SHARD_ROUTING_STRATEGY || "modulo"}`);
   console.log(`   \u2022 Test Users: ${TEST_USER_COUNT}`);
   console.log(`   \u2022 Test Table: ${testTableName}`);
+  if (missingShardIds.length > 0) {
+    console.error(`
+\u274C Missing shard URLs: ${missingShardIds.join(", ")}`);
+    process.exit(1);
+  }
   if (shards.length === 0) {
     console.error(`
 \u274C ${NO_SHARDS_CONFIGURED_MESSAGE}`);
@@ -220,7 +310,7 @@ var runTests = async () => {
       if (!urlInfo) {
         throw new Error(`Invalid URL format for ${shard.id}`);
       }
-      log.detail(`${shard.id} \u2192 ${urlInfo.host}:${urlInfo.port}/${urlInfo.database}`);
+      log.detail(`${shard.id} \u2192 ${postgresEndpoint(urlInfo)}/${urlInfo.database}`);
     }
   });
   log.section("Test 2: Network Connectivity");
@@ -228,11 +318,11 @@ var runTests = async () => {
     await runTest(`TCP connection to ${shard.id}`, async () => {
       const urlInfo = parsePostgresUrl(shard.url);
       if (!urlInfo) throw new Error("Invalid URL");
-      const connected = await testTcpConnection(urlInfo.host, urlInfo.port);
+      const connected = await testTcpConnection(urlInfo);
       if (!connected) {
-        throw new Error(`Cannot reach ${urlInfo.host}:${urlInfo.port}`);
+        throw new Error(`Cannot reach ${postgresEndpoint(urlInfo)}`);
       }
-      log.detail(`${urlInfo.host}:${urlInfo.port} is reachable`);
+      log.detail(`${postgresEndpoint(urlInfo)} is reachable`);
     });
   }
   log.section("Test 3: Database Connection");
@@ -275,10 +365,17 @@ var runTests = async () => {
     const username = `testuser_${i}`;
     const shardIndex = getShardIndex(userId, shards.length);
     const targetShard = shards[shardIndex];
-    const insertSql = `
-      INSERT INTO "${testTableName}" (id, email, username)
-      VALUES ('${userId}', '${email}', '${username}');
-    `;
+    const controlledValue = (value) => {
+      if (!/^[A-Za-z0-9_@.-]+$/.test(value)) {
+        throw new Error("Generated test value contains unsupported characters");
+      }
+      return `'${value}'`;
+    };
+    const insertSql = {
+      text: `INSERT INTO "${testTableName}" (id, email, username) VALUES ($1, $2, $3);`,
+      values: [userId, email, username],
+      psqlText: `INSERT INTO "${testTableName}" (id, email, username) VALUES (${controlledValue(userId)}, ${controlledValue(email)}, ${controlledValue(username)});`
+    };
     const result = await executeSql(targetShard.url, insertSql);
     if (result.success) {
       testUsers.push({ id: userId, email, shardId: targetShard.id });
@@ -329,7 +426,14 @@ var runTests = async () => {
       const user = testUsers[i];
       const shard = shards.find((s) => s.id === user.shardId);
       if (!shard) continue;
-      const selectSql = `SELECT id, email FROM "${testTableName}" WHERE id = '${user.id}';`;
+      if (!/^[A-Za-z0-9_@.-]+$/.test(user.id)) {
+        throw new Error("Generated test ID contains unsupported characters");
+      }
+      const selectSql = {
+        text: `SELECT id, email FROM "${testTableName}" WHERE id = $1;`,
+        values: [user.id],
+        psqlText: `SELECT id, email FROM "${testTableName}" WHERE id = '${user.id}';`
+      };
       const result = await executeSql(shard.url, selectSql);
       if (result.success && result.rows && result.rows.length > 0) {
         verified++;