prisma-sharding 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,488 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigError: () => ConfigError,
+  ConnectionError: () => ConnectionError,
+  DEFAULTS: () => DEFAULTS,
+  ERROR_MESSAGES: () => ERROR_MESSAGES,
+  PrismaSharding: () => PrismaSharding,
+  RoutingError: () => RoutingError,
+  ShardingError: () => ShardingError,
+  createDefaultLogger: () => createDefaultLogger,
+  hashString: () => hashString,
+  validateUrl: () => validateUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants/index.ts
+var DEFAULTS = {
+  POOL_MAX_CONNECTIONS: 10,
+  POOL_IDLE_TIMEOUT_MS: 1e4,
+  POOL_CONNECTION_TIMEOUT_MS: 5e3,
+  HEALTH_CHECK_INTERVAL_MS: 3e4,
+  CIRCUIT_BREAKER_THRESHOLD: 3,
+  CONSISTENT_HASH_VIRTUAL_NODES: 150
+};
+var ERROR_MESSAGES = {
+  NO_SHARDS: "At least one shard must be configured",
+  SHARD_NOT_FOUND: (id) => `Shard "${id}" not found`,
+  NO_HEALTHY_SHARDS: "No healthy shards available",
+  INVALID_STRATEGY: (s) => `Invalid routing strategy: "${s}". Use "modulo" or "consistent-hash"`,
+  NOT_CONNECTED: "Sharding not connected. Call connect() first",
+  ALREADY_CONNECTED: "Sharding already connected",
+  MISSING_CLIENT_FACTORY: "createClient function is required",
+  INVALID_SHARD_URL: (id) => `Invalid or missing URL for shard "${id}"`
+};
+
+// src/core/errors.ts
+var ShardingError = class _ShardingError extends Error {
+  constructor(message, code = "SHARDING_ERROR") {
+    super(message);
+    this.name = "ShardingError";
+    this.code = code;
+    Object.setPrototypeOf(this, _ShardingError.prototype);
+  }
+};
+var ConfigError = class _ConfigError extends ShardingError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigError";
+    Object.setPrototypeOf(this, _ConfigError.prototype);
+  }
+};
+var ConnectionError = class _ConnectionError extends ShardingError {
+  constructor(message, shardId) {
+    super(message, "CONNECTION_ERROR");
+    this.name = "ConnectionError";
+    this.shardId = shardId;
+    Object.setPrototypeOf(this, _ConnectionError.prototype);
+  }
+};
+var RoutingError = class _RoutingError extends ShardingError {
+  constructor(message) {
+    super(message, "ROUTING_ERROR");
+    this.name = "RoutingError";
+    Object.setPrototypeOf(this, _RoutingError.prototype);
+  }
+};
+
+// src/core/manager.ts
+var ShardManager = class {
+  constructor(config) {
+    this.instances = /* @__PURE__ */ new Map();
+    this.healthCheckInterval = null;
+    this.config = config;
+  }
+  async initialize() {
+    this.config.logger.info(`Initializing ${this.config.shards.length} shard(s)...`);
+    for (const shardConfig of this.config.shards) {
+      this.initializeShard(shardConfig);
+    }
+    this.startHealthChecks();
+    this.config.logger.info("All shards initialized successfully");
+  }
+  initializeShard(shardConfig) {
+    try {
+      const client = this.config.createClient(shardConfig.url, shardConfig.id);
+      const health = {
+        shardId: shardConfig.id,
+        isHealthy: true,
+        latencyMs: 0,
+        lastChecked: /* @__PURE__ */ new Date(),
+        errorCount: 0,
+        consecutiveFailures: 0
+      };
+      this.instances.set(shardConfig.id, {
+        config: shardConfig,
+        client,
+        health
+      });
+      this.config.logger.info(`Shard ${shardConfig.id} initialized`);
+    } catch (error) {
+      this.config.logger.error(`Failed to initialize shard ${shardConfig.id}: ${error}`);
+      throw new ConnectionError(`Failed to initialize shard ${shardConfig.id}`, shardConfig.id);
+    }
+  }
+  startHealthChecks() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+    }
+    this.healthCheckInterval = setInterval(async () => {
+      await this.performHealthChecks();
+    }, this.config.healthCheckIntervalMs);
+  }
+  async performHealthChecks() {
+    const checks = Array.from(this.instances.values()).map(async (instance) => {
+      const startTime = Date.now();
+      try {
+        const client = instance.client;
+        if (typeof client.$queryRaw === "function") {
+          await client.$queryRaw`SELECT 1`;
+        }
+        const latencyMs = Date.now() - startTime;
+        instance.health = {
+          ...instance.health,
+          isHealthy: true,
+          latencyMs,
+          lastChecked: /* @__PURE__ */ new Date(),
+          consecutiveFailures: 0
+        };
+      } catch (error) {
+        const consecutiveFailures = instance.health.consecutiveFailures + 1;
+        const isHealthy = consecutiveFailures < this.config.circuitBreakerThreshold;
+        instance.health = {
+          ...instance.health,
+          isHealthy,
+          latencyMs: -1,
+          lastChecked: /* @__PURE__ */ new Date(),
+          errorCount: instance.health.errorCount + 1,
+          consecutiveFailures
+        };
+        if (!isHealthy) {
+          this.config.logger.error(
+            `Shard ${instance.config.id} marked unhealthy after ${consecutiveFailures} consecutive failures`
+          );
+        }
+      }
+    });
+    await Promise.allSettled(checks);
+  }
+  getClient(shardId) {
+    const instance = this.instances.get(shardId);
+    if (!instance) {
+      throw new ConnectionError(`Shard ${shardId} not found`, shardId);
+    }
+    if (!instance.health.isHealthy) {
+      this.config.logger.warn(`Accessing unhealthy shard ${shardId}`);
+    }
+    return instance.client;
+  }
+  getClientByIndex(index) {
+    const shardId = `shard_${index + 1}`;
+    return this.getClient(shardId);
+  }
+  getAllClients() {
+    return Array.from(this.instances.values()).map((instance) => instance.client);
+  }
+  getHealthyClients() {
+    return Array.from(this.instances.values()).filter((instance) => instance.health.isHealthy).map((instance) => instance.client);
+  }
+  getShardCount() {
+    return this.instances.size;
+  }
+  getShardIds() {
+    return Array.from(this.instances.keys());
+  }
+  getHealth(shardId) {
+    return this.instances.get(shardId)?.health;
+  }
+  getAllHealth() {
+    return Array.from(this.instances.values()).map((instance) => instance.health);
+  }
+  async executeOnAll(operation) {
+    const results = await Promise.allSettled(
+      Array.from(this.instances.entries()).map(async ([shardId, instance]) => {
+        try {
+          const result = await operation(instance.client, shardId);
+          return { shardId, result, error: void 0 };
+        } catch (error) {
+          return { shardId, result: null, error };
+        }
+      })
+    );
+    return results.map((result) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      return {
+        shardId: "unknown",
+        result: null,
+        error: result.reason
+      };
+    });
+  }
+  async findFirst(operation) {
+    const results = await this.executeOnAll(operation);
+    for (const res of results) {
+      if (res.result !== null && res.result !== void 0) {
+        return { result: res.result, shardId: res.shardId };
+      }
+    }
+    return { result: null, shardId: null };
+  }
+  async shutdown() {
+    this.config.logger.info("Shutting down...");
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+    const disconnects = Array.from(this.instances.values()).map(async (instance) => {
+      try {
+        const client = instance.client;
+        if (typeof client.$disconnect === "function") {
+          await client.$disconnect();
+        }
+        this.config.logger.info(`Shard ${instance.config.id} disconnected`);
+      } catch (error) {
+        this.config.logger.error(`Error disconnecting shard ${instance.config.id}: ${error}`);
+      }
+    });
+    await Promise.allSettled(disconnects);
+    this.instances.clear();
+    this.config.logger.info("Shutdown complete");
+  }
+};
+
+// src/utils/index.ts
+function 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);
+}
+function validateUrl(url) {
+  return url.startsWith("postgresql://") || url.startsWith("postgres://");
+}
+function createDefaultLogger() {
+  return {
+    info: (msg) => console.log(`[PrismaSharding] ${msg}`),
+    warn: (msg) => console.warn(`[PrismaSharding] ${msg}`),
+    error: (msg) => console.error(`[PrismaSharding] ${msg}`)
+  };
+}
+
+// src/core/router.ts
+var ShardRouter = class {
+  constructor(config) {
+    this.consistentHashRing = /* @__PURE__ */ new Map();
+    this.virtualNodes = DEFAULTS.CONSISTENT_HASH_VIRTUAL_NODES;
+    this.strategy = config.strategy;
+    this.shardIds = config.shardIds;
+    this.logger = config.logger;
+    if (this.strategy === "consistent-hash") {
+      this.initializeConsistentHashRing();
+    }
+  }
+  initializeConsistentHashRing() {
+    for (const shardId of this.shardIds) {
+      for (let i = 0; i < this.virtualNodes; i++) {
+        const hash = hashString(`${shardId}:${i}`);
+        this.consistentHashRing.set(hash, shardId);
+      }
+    }
+  }
+  getShardIndex(key) {
+    const shardCount = this.shardIds.length;
+    if (shardCount === 0) {
+      throw new RoutingError("No shards available");
+    }
+    if (this.strategy === "consistent-hash") {
+      return this.getIndexConsistentHash(key);
+    }
+    return this.getIndexModulo(key, shardCount);
+  }
+  getIndexModulo(key, shardCount) {
+    const hash = hashString(key);
+    return hash % shardCount;
+  }
+  getIndexConsistentHash(key) {
+    const hash = hashString(key);
+    const sortedHashes = Array.from(this.consistentHashRing.keys()).sort((a, b) => a - b);
+    for (const ringHash of sortedHashes) {
+      if (hash <= ringHash) {
+        const shardId = this.consistentHashRing.get(ringHash);
+        const match2 = shardId.match(/shard_(\d+)/);
+        return match2 ? parseInt(match2[1], 10) - 1 : 0;
+      }
+    }
+    const firstShardId = this.consistentHashRing.get(sortedHashes[0]);
+    const match = firstShardId.match(/shard_(\d+)/);
+    return match ? parseInt(match[1], 10) - 1 : 0;
+  }
+  getShardId(key) {
+    const index = this.getShardIndex(key);
+    return this.shardIds[index] || `shard_${index + 1}`;
+  }
+  getRandomShardIndex() {
+    return Math.floor(Math.random() * this.shardIds.length);
+  }
+  getRandomShardId() {
+    const index = this.getRandomShardIndex();
+    return this.shardIds[index];
+  }
+};
+
+// src/core/sharding.ts
+var PrismaSharding = class {
+  constructor(config) {
+    this.manager = null;
+    this.router = null;
+    this.connected = false;
+    this.validateConfig(config);
+    this.config = config;
+    this.logger = config.logger || createDefaultLogger();
+  }
+  validateConfig(config) {
+    if (!config.shards || config.shards.length === 0) {
+      throw new ConfigError(ERROR_MESSAGES.NO_SHARDS);
+    }
+    if (!config.createClient) {
+      throw new ConfigError(ERROR_MESSAGES.MISSING_CLIENT_FACTORY);
+    }
+    for (const shard of config.shards) {
+      if (!shard.url || !validateUrl(shard.url)) {
+        throw new ConfigError(ERROR_MESSAGES.INVALID_SHARD_URL(shard.id));
+      }
+    }
+    if (config.strategy && config.strategy !== "modulo" && config.strategy !== "consistent-hash") {
+      throw new ConfigError(ERROR_MESSAGES.INVALID_STRATEGY(config.strategy));
+    }
+  }
+  async connect() {
+    if (this.connected) {
+      this.logger.warn(ERROR_MESSAGES.ALREADY_CONNECTED);
+      return;
+    }
+    this.manager = new ShardManager({
+      shards: this.config.shards,
+      createClient: this.config.createClient,
+      healthCheckIntervalMs: this.config.healthCheckIntervalMs ?? DEFAULTS.HEALTH_CHECK_INTERVAL_MS,
+      circuitBreakerThreshold: this.config.circuitBreakerThreshold ?? DEFAULTS.CIRCUIT_BREAKER_THRESHOLD,
+      logger: this.logger
+    });
+    await this.manager.initialize();
+    this.router = new ShardRouter({
+      strategy: this.config.strategy ?? "modulo",
+      shardIds: this.manager.getShardIds(),
+      logger: this.logger
+    });
+    this.connected = true;
+  }
+  async disconnect() {
+    if (!this.connected || !this.manager) {
+      return;
+    }
+    await this.manager.shutdown();
+    this.manager = null;
+    this.router = null;
+    this.connected = false;
+  }
+  ensureConnected() {
+    if (!this.connected || !this.manager || !this.router) {
+      throw new ShardingError(ERROR_MESSAGES.NOT_CONNECTED);
+    }
+  }
+  getShard(key) {
+    this.ensureConnected();
+    const shardId = this.router.getShardId(key);
+    return this.manager.getClient(shardId);
+  }
+  getShardById(shardId) {
+    this.ensureConnected();
+    return this.manager.getClient(shardId);
+  }
+  getShardWithInfo(key) {
+    this.ensureConnected();
+    const shardId = this.router.getShardId(key);
+    return {
+      shardId,
+      client: this.manager.getClient(shardId)
+    };
+  }
+  getRandomShard() {
+    this.ensureConnected();
+    const shardId = this.router.getRandomShardId();
+    return this.manager.getClient(shardId);
+  }
+  getRandomShardWithInfo() {
+    this.ensureConnected();
+    const shardId = this.router.getRandomShardId();
+    return {
+      shardId,
+      client: this.manager.getClient(shardId)
+    };
+  }
+  async findFirst(finder) {
+    this.ensureConnected();
+    const { result, shardId } = await this.manager.findFirst(finder);
+    if (result !== null && shardId !== null) {
+      return {
+        result,
+        shardId,
+        client: this.manager.getClient(shardId)
+      };
+    }
+    return { result: null, shardId: null, client: null };
+  }
+  async runOnAll(operation) {
+    this.ensureConnected();
+    const results = await this.manager.executeOnAll(operation);
+    return results.filter((r) => r.result !== null && !r.error).map((r) => r.result);
+  }
+  async runOnAllWithDetails(operation) {
+    this.ensureConnected();
+    return this.manager.executeOnAll(operation);
+  }
+  getHealth() {
+    this.ensureConnected();
+    return this.manager.getAllHealth();
+  }
+  getHealthByShard(shardId) {
+    this.ensureConnected();
+    return this.manager.getHealth(shardId);
+  }
+  getAllClients() {
+    this.ensureConnected();
+    return this.manager.getAllClients();
+  }
+  getHealthyClients() {
+    this.ensureConnected();
+    return this.manager.getHealthyClients();
+  }
+  getShardCount() {
+    this.ensureConnected();
+    return this.manager.getShardCount();
+  }
+  getShardIds() {
+    this.ensureConnected();
+    return this.manager.getShardIds();
+  }
+  isConnected() {
+    return this.connected;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigError,
+  ConnectionError,
+  DEFAULTS,
+  ERROR_MESSAGES,
+  PrismaSharding,
+  RoutingError,
+  ShardingError,
+  createDefaultLogger,
+  hashString,
+  validateUrl
+});