prisma-sharding 0.0.5 → 0.0.7

package/dist/cli/test.js

@@ -25,6 +25,114 @@ 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) => {
+  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}`);
+    }
+  }
+  if (shards.length === 0 && env.DATABASE_URL) {
+    shards.push({ id: "shard_1", index: 0, url: env.DATABASE_URL });
+  }
+  return { shards, missingShardIds };
+};
+
+// src/cli/test.ts
 var results = [];
 var testUsers = [];
 var TEST_USER_COUNT = 24;
@@ -39,20 +147,6 @@ ${"=".repeat(60)}
 ${"=".repeat(60)}`),
   detail: (msg) => console.log(`   ${msg}`)
 };
-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 });
-    }
-  }
-  if (shards.length === 0 && process.env.DATABASE_URL) {
-    shards.push({ id: "shard_1", url: process.env.DATABASE_URL });
-  }
-  return shards;
-};
 var runTest = async (name, testFn) => {
   const start = Date.now();
   try {
@@ -67,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);
@@ -101,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));
   });
 };
@@ -113,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) {
@@ -129,35 +214,42 @@ 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 stdout = "";
       let stderr = "";
-      psql.stdout?.on("data", (data) => {
-        stdout += data.toString();
-      });
       psql.stderr?.on("data", (data) => {
         stderr += data.toString();
       });
       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 })
+        });
       });
     });
   });
@@ -175,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));
@@ -187,10 +279,14 @@ 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(
-      "\n\u274C No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables."
-    );
+    console.error(`
+\u274C ${NO_SHARDS_CONFIGURED_MESSAGE}`);
     process.exit(1);
   }
   const pgAvailable = await getPgClient();
@@ -214,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");
@@ -222,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");
@@ -269,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 });
@@ -323,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++;