prisma-sharding 0.0.3 → 0.0.4

package/README.md

@@ -213,6 +213,52 @@ Test connections to all shards.
 yarn test:shards
 ```
 
+```
+================================
+📋 User Distribution Test
+================================
+Creating 24 test users across 3 shards...
+
+User 1/24: "testuser_0" → shard_3
+User 2/24: "testuser_1" → shard_1
+User 3/24: "testuser_2" → shard_2
+User 4/24: "testuser_3" → shard_3
+User 5/24: "testuser_4" → shard_1
+User 6/24: "testuser_5" → shard_2
+User 7/24: "testuser_6" → shard_3
+User 8/24: "testuser_7" → shard_1
+User 9/24: "testuser_8" → shard_2
+User 10/24: "testuser_9" → shard_3
+User 11/24: "testuser_10" → shard_2
+User 12/24: "testuser_11" → shard_1
+User 13/24: "testuser_12" → shard_3
+User 14/24: "testuser_13" → shard_2
+User 15/24: "testuser_14" → shard_1
+User 16/24: "testuser_15" → shard_3
+User 17/24: "testuser_16" → shard_2
+User 18/24: "testuser_17" → shard_1
+User 19/24: "testuser_18" → shard_3
+User 20/24: "testuser_19" → shard_2
+User 21/24: "testuser_20" → shard_1
+User 22/24: "testuser_21" → shard_3
+User 23/24: "testuser_22" → shard_2
+User 24/24: "testuser_23" → shard_1
+✅ Created 24/24 test users
+```
+
+```
+================================
+📋 Read Verification
+================================
+✓ User "test_user_1770289330292_0" found on shard_3
+✓ User "test_user_1770289330292_1" found on shard_1
+✓ User "test_user_1770289330292_2" found on shard_2
+✓ User "test_user_1770289330292_3" found on shard_3
+✓ User "test_user_1770289330292_4" found on shard_1
+Verified 5/5 users on correct shards
+✅ Verify users exist on correct shards (136ms)
+```
+
 ## Configuration
 
 | Option                    | Type                            | Default    | Description                       |

package/dist/cli/test.js

@@ -1,19 +1,43 @@
 #!/usr/bin/env node
 "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 __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
+));
 
 // src/cli/test.ts
 var import_config = require("dotenv/config");
-var import_child_process = require("child_process");
 var results = [];
+var testUsers = [];
+var TEST_USER_COUNT = 24;
 var log = {
   info: (msg) => console.log(`\u2139\uFE0F  ${msg}`),
   success: (msg) => console.log(`\u2705 ${msg}`),
   error: (msg) => console.log(`\u274C ${msg}`),
   warn: (msg) => console.log(`\u26A0\uFE0F  ${msg}`),
   section: (msg) => console.log(`
-${"=".repeat(50)}
+${"=".repeat(60)}
 \u{1F4CB} ${msg}
-${"=".repeat(50)}`)
+${"=".repeat(60)}`),
+  detail: (msg) => console.log(`   ${msg}`)
 };
 var getShardConfigs = () => {
   const shards = [];
@@ -43,78 +67,333 @@ var runTest = async (name, testFn) => {
     log.error(`${name}: ${message}`);
   }
 };
-var testConnection = (url) => {
+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) => {
   return new Promise((resolve) => {
-    const prisma = (0, import_child_process.spawn)("npx", ["prisma", "db", "execute", "--url", url, "--stdin"], {
-      shell: true,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    prisma.stdin.write("SELECT 1");
-    prisma.stdin.end();
-    prisma.on("close", (code) => {
-      resolve(code === 0);
-    });
-    prisma.on("error", () => {
-      resolve(false);
+    import("net").then(({ default: net }) => {
+      const socket = new net.Socket();
+      socket.setTimeout(5e3);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolve(false);
+      });
+      socket.connect(port, host);
+    }).catch(() => resolve(false));
+  });
+};
+var getPgClient = async () => {
+  try {
+    const pg = await import("pg");
+    return pg.default?.Client || pg.Client;
+  } catch {
+    return null;
+  }
+};
+var executeSql = async (url, sql) => {
+  const Client = await getPgClient();
+  if (!Client) {
+    return executeSqlWithPsql(url, sql);
+  }
+  const client = new Client({ connectionString: url });
+  try {
+    await client.connect();
+    const result = await client.query(sql);
+    await client.end();
+    return { success: true, rows: result.rows };
+  } catch (error) {
+    try {
+      await client.end();
+    } catch {
+    }
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+};
+var executeSqlWithPsql = (url, sql) => {
+  return new Promise((resolve) => {
+    import("child_process").then(({ spawn }) => {
+      const psql = spawn("psql", [url, "-c", sql], {
+        shell: true,
+        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);
+      psql.on("close", (code) => {
+        clearTimeout(timeout);
+        resolve({ success: code === 0, error: code !== 0 ? stderr : void 0 });
+      });
+      psql.on("error", (err) => {
+        clearTimeout(timeout);
+        resolve({ success: false, error: err.message });
+      });
     });
   });
 };
+var hashString = (str) => {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+};
+var getShardIndex = (key, shardCount) => {
+  return hashString(key) % shardCount;
+};
 var runTests = async () => {
   const shards = getShardConfigs();
-  console.log("\n\u{1F9EA} prisma-sharding: Shard Connection Test Suite\n");
-  console.log(`\u{1F4CA} Configuration:`);
-  console.log(`   - Shard Count: ${shards.length}`);
-  console.log(`   - Routing Strategy: ${process.env.SHARD_ROUTING_STRATEGY || "modulo"}`);
+  const timestamp = Date.now();
+  const testTableName = `_prisma_sharding_test_${timestamp}`;
+  console.log("\n" + "\u2550".repeat(60));
+  console.log("\u{1F9EA} PRISMA SHARDING - Comprehensive Test Suite");
+  console.log("\u2550".repeat(60));
+  console.log(`
+\u{1F4CA} Configuration:`);
+  console.log(`   \u2022 Shard Count: ${shards.length}`);
+  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 (shards.length === 0) {
     console.error(
       "\n\u274C No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables."
     );
     process.exit(1);
   }
-  log.section("Test 1: Shard Connection Tests");
-  for (const shard of shards) {
-    await runTest(`Connect to ${shard.id}`, async () => {
-      const success = await testConnection(shard.url);
-      if (!success) {
-        throw new Error(`Failed to connect to ${shard.id}`);
-      }
-    });
+  const pgAvailable = await getPgClient();
+  if (pgAvailable) {
+    console.log(`   \u2022 Database Client: pg (native)`);
+  } else {
+    console.log(`   \u2022 Database Client: psql (fallback)`);
   }
-  log.section("Test 2: Configuration Verification");
+  log.section("Test 1: Configuration Validation");
   await runTest("Verify environment variables", async () => {
     const shardCount = parseInt(process.env.SHARD_COUNT || "0", 10);
     if (shardCount === 0 && !process.env.DATABASE_URL) {
       throw new Error("SHARD_COUNT or DATABASE_URL must be set");
     }
-    log.info(`SHARD_COUNT: ${shardCount}`);
-    log.info(`Routing Strategy: ${process.env.SHARD_ROUTING_STRATEGY || "modulo"}`);
+    log.detail(`SHARD_COUNT = ${shardCount}`);
+    log.detail(`SHARD_ROUTING_STRATEGY = ${process.env.SHARD_ROUTING_STRATEGY || "modulo"}`);
   });
-  await runTest("Verify all shard URLs are present", async () => {
-    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) {
-        throw new Error(`SHARD_${i}_URL is missing`);
+  await runTest("Verify shard URL formats", async () => {
+    for (const shard of shards) {
+      const urlInfo = parsePostgresUrl(shard.url);
+      if (!urlInfo) {
+        throw new Error(`Invalid URL format for ${shard.id}`);
+      }
+      log.detail(`${shard.id} \u2192 ${urlInfo.host}:${urlInfo.port}/${urlInfo.database}`);
+    }
+  });
+  log.section("Test 2: Network Connectivity");
+  for (const shard of shards) {
+    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);
+      if (!connected) {
+        throw new Error(`Cannot reach ${urlInfo.host}:${urlInfo.port}`);
+      }
+      log.detail(`${urlInfo.host}:${urlInfo.port} is reachable`);
+    });
+  }
+  log.section("Test 3: Database Connection");
+  for (const shard of shards) {
+    await runTest(`SQL execution on ${shard.id}`, async () => {
+      const result = await executeSql(shard.url, "SELECT 1 as test;");
+      if (!result.success) {
+        throw new Error(result.error || "SQL execution failed");
+      }
+      log.detail(`${shard.id} accepts SQL commands`);
+    });
+  }
+  log.section("Test 4: Create Test Table");
+  const createTableSql = `
+    CREATE TABLE IF NOT EXISTS "${testTableName}" (
+      id VARCHAR(50) PRIMARY KEY,
+      email VARCHAR(255) NOT NULL,
+      username VARCHAR(100) NOT NULL,
+      created_at TIMESTAMP DEFAULT NOW()
+    );
+  `;
+  for (const shard of shards) {
+    await runTest(`Create test table on ${shard.id}`, async () => {
+      const result = await executeSql(shard.url, createTableSql);
+      if (!result.success) {
+        throw new Error(result.error || "Failed to create table");
+      }
+      log.detail(`Table "${testTableName}" created on ${shard.id}`);
+    });
+  }
+  log.section("Test 5: User Distribution Test");
+  console.log(`
+   Creating ${TEST_USER_COUNT} test users across ${shards.length} shards...
+`);
+  const distribution = /* @__PURE__ */ new Map();
+  shards.forEach((s) => distribution.set(s.id, 0));
+  for (let i = 0; i < TEST_USER_COUNT; i++) {
+    const userId = `test_user_${timestamp}_${i}`;
+    const email = `test_${timestamp}_${i}@example.com`;
+    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 result = await executeSql(targetShard.url, insertSql);
+    if (result.success) {
+      testUsers.push({ id: userId, email, shardId: targetShard.id });
+      distribution.set(targetShard.id, (distribution.get(targetShard.id) || 0) + 1);
+      log.detail(`User ${i + 1}/${TEST_USER_COUNT}: "${username}" \u2192 ${targetShard.id}`);
+    } else {
+      log.warn(`Failed to create user ${i + 1}: ${result.error}`);
+    }
+  }
+  log.success(`Created ${testUsers.length}/${TEST_USER_COUNT} test users`);
+  log.section("Test 6: Distribution Analysis");
+  await runTest("Analyze shard distribution", async () => {
+    console.log("\n   \u{1F4CA} User Distribution Across Shards:\n");
+    console.log("   \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    console.log("   \u2502 Shard       \u2502 Users     \u2502 Percentage \u2502 Visual             \u2502");
+    console.log("   \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+    let minCount = Infinity;
+    let maxCount = 0;
+    distribution.forEach((count, shardId) => {
+      const percentage = testUsers.length > 0 ? (count / testUsers.length * 100).toFixed(1) : "0.0";
+      const barLength = testUsers.length > 0 ? Math.round(count / testUsers.length * 15) : 0;
+      const bar = "\u2588".repeat(barLength) + "\u2591".repeat(15 - barLength);
+      console.log(
+        `   \u2502 ${shardId.padEnd(11)} \u2502 ${count.toString().padStart(9)} \u2502 ${percentage.padStart(6)}%    \u2502 ${bar}   \u2502`
+      );
+      minCount = Math.min(minCount, count);
+      maxCount = Math.max(maxCount, count);
+    });
+    console.log("   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n");
+    if (testUsers.length > 0) {
+      const minPercentage = minCount / testUsers.length * 100;
+      const maxPercentage = maxCount / testUsers.length * 100;
+      if (minPercentage < 10) {
+        log.warn(`Some shards have very few users (${minPercentage.toFixed(1)}%)`);
+      }
+      if (maxPercentage > 60) {
+        log.warn(`Some shards are overloaded (${maxPercentage.toFixed(1)}%)`);
       }
+      log.detail(`Distribution range: ${minPercentage.toFixed(1)}% - ${maxPercentage.toFixed(1)}%`);
+      log.detail(`Average per shard: ${(testUsers.length / shards.length).toFixed(1)} users`);
+    }
+  });
+  log.section("Test 7: Read Verification");
+  await runTest("Verify users exist on correct shards", async () => {
+    let verified = 0;
+    const sampleSize = Math.min(5, testUsers.length);
+    for (let i = 0; i < sampleSize; i++) {
+      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}';`;
+      const result = await executeSql(shard.url, selectSql);
+      if (result.success && result.rows && result.rows.length > 0) {
+        verified++;
+        log.detail(`\u2713 User "${user.id}" found on ${user.shardId}`);
+      } else {
+        log.warn(`\u2717 User "${user.id}" NOT found on ${user.shardId}`);
+      }
+    }
+    if (verified < sampleSize) {
+      throw new Error(`Only ${verified}/${sampleSize} users verified`);
     }
+    log.detail(`Verified ${verified}/${sampleSize} users on correct shards`);
   });
-  log.section("Test Results Summary");
+  log.section("Test 8: Cross-Shard Count");
+  await runTest("Count users across all shards", async () => {
+    let totalCount = 0;
+    for (const shard of shards) {
+      const countSql = `SELECT COUNT(*) as count FROM "${testTableName}";`;
+      const result = await executeSql(shard.url, countSql);
+      if (result.success && result.rows && result.rows.length > 0) {
+        const count = parseInt(result.rows[0].count, 10);
+        totalCount += count;
+        log.detail(`${shard.id}: ${count} users`);
+      }
+    }
+    log.detail(`Total users across all shards: ${totalCount}`);
+    if (totalCount !== testUsers.length) {
+      log.warn(`Expected ${testUsers.length} users, found ${totalCount}`);
+    }
+  });
+  log.section("Test 9: Cleanup");
+  let cleanedUp = 0;
+  for (const shard of shards) {
+    const dropSql = `DROP TABLE IF EXISTS "${testTableName}";`;
+    const result = await executeSql(shard.url, dropSql);
+    if (result.success) {
+      cleanedUp++;
+      log.detail(`Test table removed from ${shard.id}`);
+    } else {
+      log.warn(`Could not drop table on ${shard.id}: ${result.error}`);
+    }
+  }
+  log.success(`Cleanup complete (${cleanedUp}/${shards.length} shards)`);
+  console.log("\n" + "\u2550".repeat(60));
+  console.log("\u{1F4CB} TEST RESULTS SUMMARY");
+  console.log("\u2550".repeat(60));
   const passed = results.filter((r) => r.passed).length;
   const failed = results.filter((r) => !r.passed).length;
   const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
   console.log(`
    Total Tests: ${results.length}`);
-  console.log(`   Passed: ${passed}`);
-  console.log(`   Failed: ${failed}`);
-  console.log(`   Duration: ${totalDuration}ms`);
+  console.log(`   \u2705 Passed: ${passed}`);
+  console.log(`   \u274C Failed: ${failed}`);
+  console.log(`   \u23F1\uFE0F  Duration: ${(totalDuration / 1e3).toFixed(2)}s`);
+  console.log(`   \u{1F4CA} Users Created: ${testUsers.length}`);
   if (failed > 0) {
     console.log("\n   Failed Tests:");
     results.filter((r) => !r.passed).forEach((r) => {
-      console.log(`     - ${r.name}: ${r.message}`);
+      console.log(`     \u2022 ${r.name}: ${r.message}`);
     });
+    console.log("\n\u{1F4A1} Troubleshooting Tips:");
+    console.log("   \u2022 Ensure PostgreSQL is running");
+    console.log("   \u2022 Verify shard databases exist");
+    console.log("   \u2022 Check credentials in SHARD_N_URL");
+    console.log("   \u2022 Run: yarn migrate:shards\n");
     process.exit(1);
   }
-  console.log("\n\u2705 All shard tests passed!");
+  console.log("\n" + "\u2550".repeat(60));
+  console.log("\u2705 ALL TESTS PASSED SUCCESSFULLY!");
+  console.log("\u2550".repeat(60) + "\n");
 };
 runTests().catch((error) => {
   console.error("\n\u{1F4A5} Test suite crashed:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-sharding",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Lightweight database sharding library for Prisma with connection pooling and health monitoring",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -50,10 +50,12 @@
     "@prisma/client": ">=5.0.0"
   },
   "dependencies": {
-    "dotenv": "^16.3.1"
+    "dotenv": "^16.3.1",
+    "pg": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
+    "@types/pg": "^8.16.0",
     "@typescript-eslint/eslint-plugin": "^6.13.0",
     "@typescript-eslint/parser": "^6.13.0",
     "eslint": "^8.55.0",