prisma-sharding 0.0.4 → 0.0.6

package/dist/cli/test.js

@@ -25,6 +25,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/test.ts
 var import_config = require("dotenv/config");
+
+// 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 };
+};
+var getShardConfigs = (env = process.env) => {
+  return getShardConfigResult(env).shards;
+};
+
+// src/cli/test.ts
 var results = [];
 var testUsers = [];
 var TEST_USER_COUNT = 24;
@@ -39,20 +64,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 {
@@ -139,11 +150,7 @@ var executeSqlWithPsql = (url, 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();
       });
@@ -188,9 +195,8 @@ var runTests = async () => {
   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."
-    );
+    console.error(`
+\u274C ${NO_SHARDS_CONFIGURED_MESSAGE}`);
     process.exit(1);
   }
   const pgAvailable = await getPgClient();

package/dist/cli/update.js

@@ -0,0 +1,249 @@
+#!/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/update.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/command.ts
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
+var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+var runCommand = (command, args, options = {}) => {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const child = (0, import_child_process.spawn)(command, args, {
+      env: options.env || process.env,
+      cwd: import_path.default.resolve(options.cwd || process.cwd()),
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const settle = (result) => {
+      if (!settled) {
+        settled = true;
+        resolve(result);
+      }
+    };
+    child.stdout?.on("data", (data) => {
+      const output = data.toString();
+      stdout += output;
+      if (options.verbose) {
+        process.stdout.write(output);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const output = data.toString();
+      stderr += output;
+      if (options.verbose) {
+        process.stderr.write(output);
+      }
+    });
+    child.once("error", (error) => {
+      settle({
+        success: false,
+        stdout,
+        stderr,
+        error: error.message
+      });
+    });
+    child.once("close", (exitCode) => {
+      settle({
+        success: exitCode === 0,
+        stdout,
+        stderr,
+        exitCode,
+        error: exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${exitCode}`
+      });
+    });
+  });
+};
+var runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
+
+// 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/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 };
+};
+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(/:[^:@]+@/, ":***@");
+  }
+};
+
+// 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)}
+`);
+    }
+    const result = await runPrismaCommand(
+      ["db", "push", "--accept-data-loss", ...extraArgs],
+      {
+        env: { ...process.env, DATABASE_URL: shard.url },
+        verbose
+      }
+    );
+    if (verbose && result.error && !result.stderr.trim() && !result.stdout.trim()) {
+      console.error(result.error);
+    }
+    results.push({ shardId: shard.id, success: result.success });
+    if (result.success) {
+      loader.succeed("Synced");
+    } else {
+      loader.fail("Failed");
+    }
+  }
+  return results;
+};
+
+// src/cli/update.ts
+var updateAll = async () => {
+  const verbose = isVerboseEnv(["SHARD_UPDATE_VERBOSE", "SHARD_CLI_VERBOSE"]);
+  const shards = getShardConfigs();
+  const extraArgs = process.argv.slice(2);
+  printCliHeader("\u{1F504}", "Prisma Sharding Update");
+  if (shards.length === 0) {
+    printCliRow("\u274C", "config", NO_SHARDS_CONFIGURED_MESSAGE);
+    process.exit(1);
+  }
+  if (verbose) {
+    console.log("Generating Prisma Client...\n");
+  }
+  const generateLoader = createCliLoader("client", "Generating", !verbose);
+  const generateResult = await runPrismaCommand(["generate"], { verbose });
+  if (verbose && generateResult.error && !generateResult.stderr.trim() && !generateResult.stdout.trim()) {
+    console.error(generateResult.error);
+  }
+  if (!generateResult.success) {
+    generateLoader.fail("Generation failed");
+    if (!verbose) {
+      printVerboseHint();
+    }
+    process.exit(1);
+  }
+  generateLoader.succeed("Generated");
+  const results = await syncShardSchemas(shards, extraArgs, verbose);
+  const successful = results.filter((result) => result.success).length;
+  const failed = results.length - successful;
+  if (failed > 0) {
+    if (!verbose) {
+      printVerboseHint();
+    }
+    process.exit(1);
+  }
+};
+updateAll().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/dist/index.d.mts

@@ -68,6 +68,10 @@ declare class PrismaSharding<TClient> {
     getShardById(shardId: string): TClient;
     getShardWithInfo(key: string): ShardResult<TClient>;
     getRandomShard(): TClient;
+    /**
+     * Returns both the random shard client and its shardId.
+     * Used when the shardId must be stored on the user record for future routing.
+     */
     getRandomShardWithInfo(): ShardResult<TClient>;
     findFirst<T>(finder: (client: TClient) => Promise<T | null>): Promise<FindFirstResult<T, TClient>>;
     runOnAll<T>(operation: (client: TClient, shardId: string) => Promise<T>): Promise<T[]>;

package/dist/index.d.ts

@@ -68,6 +68,10 @@ declare class PrismaSharding<TClient> {
     getShardById(shardId: string): TClient;
     getShardWithInfo(key: string): ShardResult<TClient>;
     getRandomShard(): TClient;
+    /**
+     * Returns both the random shard client and its shardId.
+     * Used when the shardId must be stored on the user record for future routing.
+     */
     getRandomShardWithInfo(): ShardResult<TClient>;
     findFirst<T>(finder: (client: TClient) => Promise<T | null>): Promise<FindFirstResult<T, TClient>>;
     runOnAll<T>(operation: (client: TClient, shardId: string) => Promise<T>): Promise<T[]>;

package/dist/index.js

@@ -33,6 +33,15 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// 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());
+};
+
 // src/utils/index.ts
 function hashString(str) {
   let hash = 0;
@@ -47,8 +56,13 @@ function validateUrl(url) {
   return url.startsWith("postgresql://") || url.startsWith("postgres://");
 }
 function createDefaultLogger() {
+  const verbose = parseBooleanEnv("PRISMA_SHARDING_VERBOSE", false);
   return {
-    info: (msg) => console.log(`[PrismaSharding] ${msg}`),
+    info: (msg) => {
+      if (verbose) {
+        console.log(`[PrismaSharding] ${msg}`);
+      }
+    },
     warn: (msg) => console.warn(`[PrismaSharding] ${msg}`),
     error: (msg) => console.error(`[PrismaSharding] ${msg}`)
   };
@@ -416,6 +430,10 @@ var PrismaSharding = class {
     const shardId = this.router.getRandomShardId();
     return this.manager.getClient(shardId);
   }
+  /**
+   * Returns both the random shard client and its shardId.
+   * Used when the shardId must be stored on the user record for future routing.
+   */
   getRandomShardWithInfo() {
     this.ensureConnected();
     const shardId = this.router.getRandomShardId();

package/dist/index.mjs

@@ -1,3 +1,12 @@
+// 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());
+};
+
 // src/utils/index.ts
 function hashString(str) {
   let hash = 0;
@@ -12,8 +21,13 @@ function validateUrl(url) {
   return url.startsWith("postgresql://") || url.startsWith("postgres://");
 }
 function createDefaultLogger() {
+  const verbose = parseBooleanEnv("PRISMA_SHARDING_VERBOSE", false);
   return {
-    info: (msg) => console.log(`[PrismaSharding] ${msg}`),
+    info: (msg) => {
+      if (verbose) {
+        console.log(`[PrismaSharding] ${msg}`);
+      }
+    },
     warn: (msg) => console.warn(`[PrismaSharding] ${msg}`),
     error: (msg) => console.error(`[PrismaSharding] ${msg}`)
   };
@@ -381,6 +395,10 @@ var PrismaSharding = class {
     const shardId = this.router.getRandomShardId();
     return this.manager.getClient(shardId);
   }
+  /**
+   * Returns both the random shard client and its shardId.
+   * Used when the shardId must be stored on the user record for future routing.
+   */
   getRandomShardWithInfo() {
     this.ensureConnected();
     const shardId = this.router.getRandomShardId();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-sharding",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Lightweight database sharding library for Prisma with connection pooling and health monitoring",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -20,6 +20,7 @@
   ],
   "bin": {
     "prisma-sharding-migrate": "./dist/cli/migrate.js",
+    "prisma-sharding-update": "./dist/cli/update.js",
     "prisma-sharding-studio": "./dist/cli/studio.js",
     "prisma-sharding-test": "./dist/cli/test.js"
   },
@@ -34,11 +35,12 @@
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --clean && tsup src/cli/migrate.ts src/cli/studio.ts src/cli/test.ts --format cjs --outDir dist/cli --clean",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean && tsup src/cli/migrate.ts src/cli/studio.ts src/cli/test.ts src/cli/update.ts --format cjs --outDir dist/cli --clean",
     "build:lib": "tsup src/index.ts --format cjs,esm --dts --clean",
-    "build:cli": "tsup src/cli/migrate.ts src/cli/studio.ts src/cli/test.ts --format cjs --outDir dist/cli",
+    "build:cli": "tsup src/cli/migrate.ts src/cli/studio.ts src/cli/test.ts src/cli/update.ts --format cjs --outDir dist/cli",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
     "lint": "eslint src --ext .ts",
+    "test": "yarn build && node --test test/*.test.js",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "yarn build",
     "patch": "yarn version --patch && yarn publish",