@delali/sirannon-db 0.1.3 → 0.1.5

package/dist/server/index.mjs

@@ -1,6 +1,7 @@
-import { ChangeTracker, SubscriptionManager, SirannonError } from '../chunk-VI4UP4RR.mjs';
+import { ChangeTracker, SubscriptionManager } from '../chunk-UTO3ZAFS.mjs';
+import '../chunk-GS7T5YMI.mjs';
+import { SirannonError } from '../chunk-O7BHI3CF.mjs';
 import uWS from 'uWebSockets.js';
-import SqliteDatabase from 'better-sqlite3';
 
 // src/server/protocol.ts
 function toExecuteResponse(result) {
@@ -19,7 +20,7 @@ function handleLiveness() {
     });
   };
 }
-function handleReadiness(sirannon) {
+function handleReadiness(sirannon, getReplicationStatus) {
   return (res) => {
     const dbs = sirannon.databases();
     const databases = [];
@@ -37,12 +38,43 @@ function handleReadiness(sirannon) {
       status: degraded ? "degraded" : "ok",
       databases
     };
+    if (getReplicationStatus) {
+      const replStatus = getReplicationStatus();
+      if (replStatus) {
+        body.replication = {
+          role: replStatus.role,
+          writeForwarding: replStatus.writeForwarding,
+          peers: replStatus.peers,
+          localSeq: replStatus.localSeq.toString(),
+          replicationGroupId: replStatus.replicationGroupId,
+          primaryTerm: replStatus.primaryTerm?.toString(),
+          currentPrimary: replStatus.currentPrimary,
+          coordinator: replStatus.coordinator,
+          controller: replStatus.controller,
+          inSyncReplicas: replStatus.inSyncReplicas,
+          laggingReplicas: replStatus.laggingReplicas,
+          syncState: replStatus.syncState,
+          readAvailability: replStatus.readAvailability,
+          writeAvailability: replStatus.writeAvailability
+        };
+        body.status = readinessStatusForReplication(replStatus, body.status);
+      }
+    }
     const payload = JSON.stringify(body);
     res.cork(() => {
       res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
     });
   };
 }
+function readinessStatusForReplication(replication, current) {
+  if (replication.syncState === "syncing" || replication.syncState === "catching-up") return "syncing";
+  if (replication.controller?.state === "active" && replication.writeAvailability === "unavailable")
+    return "failing_over";
+  if (replication.readAvailability === "unavailable" && replication.writeAvailability === "unavailable")
+    return "unavailable";
+  if ((replication.laggingReplicas?.length ?? 0) > 0) return "degraded";
+  return current;
+}
 
 // src/server/http-handler.ts
 function initAbortHandler(res) {
@@ -116,8 +148,8 @@ function sendJson(res, data) {
     res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
   });
 }
-function sendError(res, status, code, message) {
-  const body = { error: { code, message } };
+function sendError(res, status, code, message, details) {
+  const body = { error: details ? { code, message, details } : { code, message } };
   const payload = JSON.stringify(body);
   res.cork(() => {
     res.writeStatus(`${status}`).writeHeader("Content-Type", "application/json").end(payload);
@@ -132,69 +164,105 @@ function httpStatusForError(err) {
     case "QUERY_ERROR":
     case "TRANSACTION_ERROR":
       return 400;
+    case "STALE_PRIMARY":
+    case "PROTOCOL_VERSION_MISMATCH":
+      return 409;
     case "HOOK_DENIED":
       return 403;
     case "DATABASE_CLOSED":
     case "SHUTDOWN":
+    case "READ_CONCERN_ERROR":
+    case "COORDINATOR_UNAVAILABLE":
+    case "AUTHORITY_LOST":
+    case "NO_SAFE_PRIMARY":
+    case "NODE_NOT_IN_SYNC":
+    case "NODE_DRAINING":
+    case "UNSAFE_RECOVERY_REQUIRED":
       return 503;
     default:
       return 500;
   }
 }
-function resolveDatabase(res, sirannon, id) {
-  const db = sirannon.get(id);
-  if (!db) {
+async function resolveExecutionTarget(res, sirannon, id, resolver) {
+  let target;
+  try {
+    target = resolver ? await resolver(id) : await sirannon.resolve(id);
+  } catch (err) {
+    if (err instanceof SirannonError) {
+      sendError(res, httpStatusForError(err), err.code, err.message);
+    } else {
+      sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
+    }
+    return null;
+  }
+  if (!target) {
     sendError(res, 404, "DATABASE_NOT_FOUND", `Database '${id}' not found`);
     return null;
   }
-  return db;
+  return target;
 }
-function handleQuery(sirannon) {
-  return (res, dbId, rawBody) => {
+function handleQuery(sirannon, resolveTarget) {
+  return async (res, dbId, rawBody, abort) => {
     const body = parseBody(res, rawBody);
     if (!body) return;
     if (!body.sql || typeof body.sql !== "string") {
       sendError(res, 400, "INVALID_REQUEST", 'Field "sql" is required and must be a string');
       return;
     }
-    const db = resolveDatabase(res, sirannon, dbId);
-    if (!db) return;
+    const readConcern = parseReadConcern(res, body.readConcern);
+    if (!readConcern.ok) return;
+    const target = await resolveExecutionTarget(res, sirannon, dbId, resolveTarget);
+    if (!target) return;
     try {
-      const rows = db.query(body.sql, body.params);
+      const rows = await target.query(
+        body.sql,
+        body.params,
+        readConcern.value ? { readConcern: readConcern.value } : void 0
+      );
+      if (abort.aborted) return;
       sendJson(res, { rows });
     } catch (err) {
+      if (abort.aborted) return;
       if (err instanceof SirannonError) {
-        sendError(res, httpStatusForError(err), err.code, err.message);
+        sendError(res, httpStatusForError(err), err.code, err.message, errorDetails(err));
       } else {
         sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
       }
     }
   };
 }
-function handleExecute(sirannon) {
-  return (res, dbId, rawBody) => {
+function handleExecute(sirannon, resolveTarget) {
+  return async (res, dbId, rawBody, abort) => {
     const body = parseBody(res, rawBody);
     if (!body) return;
     if (!body.sql || typeof body.sql !== "string") {
       sendError(res, 400, "INVALID_REQUEST", 'Field "sql" is required and must be a string');
       return;
     }
-    const db = resolveDatabase(res, sirannon, dbId);
-    if (!db) return;
+    const writeConcern = parseWriteConcern(res, body.writeConcern);
+    if (!writeConcern.ok) return;
+    const target = await resolveExecutionTarget(res, sirannon, dbId, resolveTarget);
+    if (!target) return;
     try {
-      const result = db.execute(body.sql, body.params);
+      const result = await target.execute(
+        body.sql,
+        body.params,
+        writeConcern.value ? { writeConcern: writeConcern.value } : void 0
+      );
+      if (abort.aborted) return;
       sendJson(res, toExecuteResponse(result));
     } catch (err) {
+      if (abort.aborted) return;
       if (err instanceof SirannonError) {
-        sendError(res, httpStatusForError(err), err.code, err.message);
+        sendError(res, httpStatusForError(err), err.code, err.message, errorDetails(err));
       } else {
         sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
       }
     }
   };
 }
-function handleTransaction(sirannon) {
-  return (res, dbId, rawBody) => {
+function handleTransaction(sirannon, resolveTarget) {
+  return async (res, dbId, rawBody, abort) => {
     const body = parseBody(res, rawBody);
     if (!body) return;
     if (!Array.isArray(body.statements)) {
@@ -205,6 +273,8 @@ function handleTransaction(sirannon) {
       sendError(res, 400, "INVALID_REQUEST", "Transaction requires at least one statement");
       return;
     }
+    const writeConcern = parseWriteConcern(res, body.writeConcern);
+    if (!writeConcern.ok) return;
     for (let i = 0; i < body.statements.length; i++) {
       const stmt = body.statements[i];
       if (!stmt.sql || typeof stmt.sql !== "string") {
@@ -212,50 +282,138 @@ function handleTransaction(sirannon) {
         return;
       }
     }
-    const db = resolveDatabase(res, sirannon, dbId);
-    if (!db) return;
+    const target = await resolveExecutionTarget(res, sirannon, dbId, resolveTarget);
+    if (!target) return;
     try {
-      const results = db.transaction((tx) => {
-        return body.statements.map((stmt) => tx.execute(stmt.sql, stmt.params));
-      });
+      const results = await target.transaction(
+        async (tx) => {
+          const txResults = [];
+          for (const stmt of body.statements) {
+            if (abort.aborted) throw new Error("Request aborted");
+            txResults.push(await tx.execute(stmt.sql, stmt.params));
+          }
+          return txResults;
+        },
+        writeConcern.value ? { writeConcern: writeConcern.value } : void 0
+      );
+      if (abort.aborted) return;
       sendJson(res, {
         results: results.map(toExecuteResponse)
       });
     } catch (err) {
+      if (abort.aborted) return;
       if (err instanceof SirannonError) {
-        sendError(res, httpStatusForError(err), err.code, err.message);
+        sendError(res, httpStatusForError(err), err.code, err.message, errorDetails(err));
       } else {
         sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
       }
     }
   };
 }
+function parseReadConcern(res, value) {
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!isPlainRecord(value)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "readConcern" must be an object when provided');
+    return { ok: false };
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1 || !keys.includes("level")) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "readConcern" must contain only "level"');
+    return { ok: false };
+  }
+  if (!isReadConcernLevel(value.level)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "readConcern.level" is invalid');
+    return { ok: false };
+  }
+  return { ok: true, value: { level: value.level } };
+}
+function parseWriteConcern(res, value) {
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!isPlainRecord(value)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern" must be an object when provided');
+    return { ok: false };
+  }
+  const allowedKeys = /* @__PURE__ */ new Set(["level", "timeoutMs"]);
+  if (!Object.keys(value).every((key) => allowedKeys.has(key))) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern" contains unsupported keys');
+    return { ok: false };
+  }
+  if (!isWriteConcernLevel(value.level)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern.level" is invalid');
+    return { ok: false };
+  }
+  const timeoutMs = value.timeoutMs;
+  if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern.timeoutMs" must be a positive safe integer');
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    value: timeoutMs === void 0 ? { level: value.level } : { level: value.level, timeoutMs }
+  };
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isReadConcernLevel(value) {
+  return value === "local" || value === "majority" || value === "linearizable";
+}
+function isWriteConcernLevel(value) {
+  return value === "local" || value === "majority" || value === "all";
+}
+function handleClusterStatus(getClusterStatus) {
+  return (res, dbId) => {
+    if (!getClusterStatus) {
+      sendError(res, 404, "NOT_FOUND", "Cluster status is not configured");
+      return;
+    }
+    const status = getClusterStatus(dbId);
+    if (!status) {
+      sendError(res, 404, "DATABASE_NOT_FOUND", `Database '${dbId}' not found`);
+      return;
+    }
+    sendJson(res, toClusterStatusResponse(status));
+  };
+}
+function toClusterStatusResponse(status) {
+  return {
+    ...status,
+    currentPrimary: status.currentPrimary ? { ...status.currentPrimary } : status.currentPrimary,
+    readEndpoints: status.readEndpoints?.map((endpoint) => ({
+      ...endpoint,
+      readConcerns: [...endpoint.readConcerns]
+    })),
+    primaryTerm: status.primaryTerm?.toString()
+  };
+}
+function errorDetails(err) {
+  const details = err.details;
+  return details && Object.keys(details).length > 0 ? details : void 0;
+}
+
+// src/server/ws-handler.ts
 var DEFAULT_POLL_INTERVAL_MS = 50;
 var DEFAULT_MAX_PAYLOAD_LENGTH = 1048576;
 var WSHandler = class {
   sirannon;
   maxPayloadLength;
+  resolveExecutionTarget;
   connections = /* @__PURE__ */ new Map();
   cdcContexts = /* @__PURE__ */ new Map();
+  cdcPending = /* @__PURE__ */ new Map();
   closed = false;
   constructor(sirannon, options) {
     this.sirannon = sirannon;
     this.maxPayloadLength = options?.maxPayloadLength ?? DEFAULT_MAX_PAYLOAD_LENGTH;
+    this.resolveExecutionTarget = options?.resolveExecutionTarget;
   }
-  // --- Public API ---
-  /**
-   * Register a new WebSocket connection for the given database.
-   *
-   * Sends an error and closes the connection if the database does not exist,
-   * is closed, or the handler itself has been shut down.
-   */
-  handleOpen(conn, databaseId) {
+  async handleOpen(conn, databaseId) {
     if (this.closed) {
       this.sendError(conn, "", "HANDLER_CLOSED", "WebSocket handler is shut down");
       conn.close(1013, "Handler shutting down");
       return;
     }
-    const database = this.sirannon.get(databaseId);
+    const database = await this.sirannon.resolve(databaseId);
     if (!database) {
       this.sendError(conn, "", "DATABASE_NOT_FOUND", `Database '${databaseId}' not found`);
       conn.close(1008, "Database not found");
@@ -266,18 +424,26 @@ var WSHandler = class {
       conn.close(1008, "Database closed");
       return;
     }
+    let executionTarget;
+    try {
+      executionTarget = await this.resolveTarget(databaseId);
+    } catch (err) {
+      this.sendSirannonError(conn, "", err);
+      conn.close(1011, "Execution target resolution failed");
+      return;
+    }
+    if (!executionTarget) {
+      this.sendError(conn, "", "DATABASE_NOT_FOUND", `Database '${databaseId}' not found`);
+      conn.close(1008, "Database not found");
+      return;
+    }
     this.connections.set(conn, {
       databaseId,
       database,
+      executionTarget,
       subscriptions: /* @__PURE__ */ new Map()
     });
   }
-  /**
-   * Process an incoming WebSocket message.
-   *
-   * Validates the JSON payload, extracts the message type and correlation ID,
-   * and routes to the appropriate handler.
-   */
   handleMessage(conn, data) {
     const state = this.connections.get(conn);
     if (!state) return;
@@ -322,12 +488,6 @@ var WSHandler = class {
         this.sendError(conn, id, "UNKNOWN_TYPE", `Unknown message type: '${msg.type}'`);
     }
   }
-  /**
-   * Clean up after a WebSocket connection closes.
-   *
-   * Unsubscribes all active CDC subscriptions for this connection and
-   * releases the per-database CDC context if no subscribers remain.
-   */
   handleClose(conn) {
     const state = this.connections.get(conn);
     if (!state) return;
@@ -338,17 +498,10 @@ var WSHandler = class {
     this.maybeCleanupCDC(state.databaseId);
     this.connections.delete(conn);
   }
-  /** Number of active WebSocket connections. */
   get connectionCount() {
     return this.connections.size;
   }
-  /**
-   * Shut down the handler.
-   *
-   * Unsubscribes all CDC subscriptions, closes all WebSocket connections
-   * with code 1001 (Going Away), and releases all CDC resources.
-   */
-  close() {
+  async close() {
     if (this.closed) return;
     this.closed = true;
     for (const [conn, state] of this.connections) {
@@ -362,14 +515,13 @@ var WSHandler = class {
     for (const ctx of this.cdcContexts.values()) {
       ctx.stopPolling();
       try {
-        ctx.cdcDb.close();
+        await ctx.cdcConn.close();
       } catch {
       }
     }
     this.cdcContexts.clear();
   }
-  // --- Private message handlers ---
-  handleQuery(conn, state, msg, id) {
+  async handleQuery(conn, state, msg, id) {
     if (typeof msg.sql !== "string") {
       this.sendError(conn, id, "INVALID_MESSAGE", 'Query message requires a "sql" string field');
       return;
@@ -380,13 +532,13 @@ var WSHandler = class {
     }
     try {
       const params = msg.params ?? void 0;
-      const rows = state.database.query(msg.sql, params);
+      const rows = await state.executionTarget.query(msg.sql, params);
       this.send(conn, { type: "result", id, data: { rows } });
     } catch (err) {
       this.sendSirannonError(conn, id, err);
     }
   }
-  handleExecute(conn, state, msg, id) {
+  async handleExecute(conn, state, msg, id) {
     if (typeof msg.sql !== "string") {
       this.sendError(conn, id, "INVALID_MESSAGE", 'Execute message requires a "sql" string field');
       return;
@@ -397,7 +549,7 @@ var WSHandler = class {
     }
     try {
       const params = msg.params ?? void 0;
-      const result = state.database.execute(msg.sql, params);
+      const result = await state.executionTarget.execute(msg.sql, params);
       this.send(conn, {
         type: "result",
         id,
@@ -407,7 +559,7 @@ var WSHandler = class {
       this.sendSirannonError(conn, id, err);
     }
   }
-  handleSubscribe(conn, state, msg, id) {
+  async handleSubscribe(conn, state, msg, id) {
     if (typeof msg.table !== "string") {
       this.sendError(conn, id, "INVALID_MESSAGE", 'Subscribe message requires a "table" string field');
       return;
@@ -429,15 +581,19 @@ var WSHandler = class {
       return;
     }
     const filter = msg.filter ?? void 0;
+    let ctx = null;
     try {
-      const ctx = this.ensureCDC(state.databaseId, state.database);
-      ctx.tracker.watch(ctx.cdcDb, msg.table);
+      ctx = await this.ensureCDC(state.databaseId, state.database);
+      await ctx.tracker.watch(ctx.cdcConn, msg.table);
       const sub = ctx.manager.subscribe(msg.table, filter, (event) => {
         this.sendChange(conn, id, event);
       });
       state.subscriptions.set(id, sub);
       this.send(conn, { type: "subscribed", id });
     } catch (err) {
+      if (ctx?.manager.size === 0) {
+        this.maybeCleanupCDC(state.databaseId);
+      }
       this.sendSirannonError(conn, id, err);
     }
   }
@@ -452,31 +608,50 @@ var WSHandler = class {
     this.send(conn, { type: "unsubscribed", id });
     this.maybeCleanupCDC(state.databaseId);
   }
-  // --- CDC management ---
-  /**
-   * Get or create a CDC context for the given database.
-   *
-   * Opens a separate better-sqlite3 connection for trigger installation and
-   * change polling. WAL mode and a 5-second busy timeout are set so that
-   * the CDC connection coexists with the Database class's connection pool.
-   */
-  ensureCDC(databaseId, database) {
+  async ensureCDC(databaseId, database) {
     const existing = this.cdcContexts.get(databaseId);
     if (existing) return existing;
-    const cdcDb = new SqliteDatabase(database.path);
-    cdcDb.pragma("journal_mode = WAL");
-    cdcDb.pragma("busy_timeout = 5000");
+    const pending = this.cdcPending.get(databaseId);
+    if (pending) return pending;
+    const promise = this.createCDCContext(database);
+    this.cdcPending.set(databaseId, promise);
+    try {
+      const ctx = await promise;
+      if (this.closed) {
+        ctx.stopPolling();
+        await ctx.cdcConn.close().catch(() => {
+        });
+        throw new SirannonError("WebSocket handler is shut down", "HANDLER_CLOSED");
+      }
+      this.cdcContexts.set(databaseId, ctx);
+      return ctx;
+    } finally {
+      this.cdcPending.delete(databaseId);
+    }
+  }
+  async createCDCContext(database) {
+    const cdcConn = await this.sirannon.driver.open(database.path, { walMode: true });
     const tracker = new ChangeTracker();
     const manager = new SubscriptionManager();
+    try {
+      await tracker.advanceToLatest(cdcConn);
+    } catch (err) {
+      await cdcConn.close().catch(() => {
+      });
+      throw err;
+    }
+    let polling = false;
     let consecutiveErrors = 0;
     const MAX_CONSECUTIVE_ERRORS = 10;
     const stopPolling = () => {
       clearInterval(interval);
     };
-    const tick = () => {
+    const tick = async () => {
       if (manager.size === 0) return;
+      if (polling) return;
+      polling = true;
       try {
-        const events = tracker.poll(cdcDb);
+        const events = await tracker.poll(cdcConn);
         if (events.length > 0) {
           manager.dispatch(events);
         }
@@ -486,35 +661,32 @@ var WSHandler = class {
         if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
           stopPolling();
         }
+      } finally {
+        polling = false;
       }
     };
     const interval = setInterval(tick, DEFAULT_POLL_INTERVAL_MS);
-    if (typeof interval.unref === "function") interval.unref();
-    const ctx = { cdcDb, tracker, manager, stopPolling };
-    this.cdcContexts.set(databaseId, ctx);
-    return ctx;
-  }
-  /**
-   * Release CDC resources for a database if no subscribers remain.
-   *
-   * Stops the polling loop and closes the dedicated CDC connection.
-   */
+    interval.unref?.();
+    return { cdcConn, tracker, manager, stopPolling };
+  }
   maybeCleanupCDC(databaseId) {
     const ctx = this.cdcContexts.get(databaseId);
     if (!ctx || ctx.manager.size > 0) return;
     ctx.stopPolling();
-    try {
-      ctx.cdcDb.close();
-    } catch {
-    }
+    ctx.cdcConn.close().catch(() => {
+    });
     this.cdcContexts.delete(databaseId);
   }
-  // --- Validation ---
   isValidParams(params) {
     if (params === void 0 || params === null) return true;
     return typeof params === "object";
   }
-  // --- Send helpers ---
+  async resolveTarget(databaseId) {
+    if (!this.resolveExecutionTarget) {
+      return await this.sirannon.resolve(databaseId) ?? null;
+    }
+    return await this.resolveExecutionTarget(databaseId) ?? null;
+  }
   send(conn, msg) {
     try {
       conn.send(JSON.stringify(msg));
@@ -578,6 +750,10 @@ function writeCorsOrigin(res, cors, requestOrigin) {
     res.writeHeader("Vary", "Origin");
   }
 }
+function selectWebSocketProtocol(header) {
+  const [firstProtocol] = header.split(",");
+  return firstProtocol?.trim() ?? "";
+}
 function decodeRemoteAddress(res) {
   return Buffer.from(res.getRemoteAddressAsText()).toString();
 }
@@ -604,6 +780,9 @@ var SirannonServer = class {
   port;
   cors;
   onRequestHook;
+  resolveExecutionTarget;
+  getReplicationStatus;
+  getClusterStatus;
   sirannon;
   wsHandler;
   constructor(sirannon, options) {
@@ -612,7 +791,10 @@ var SirannonServer = class {
     this.port = options?.port ?? 9876;
     this.cors = resolveCors(options?.cors);
     this.onRequestHook = options?.onRequest;
-    this.wsHandler = new WSHandler(sirannon);
+    this.resolveExecutionTarget = options?.resolveExecutionTarget;
+    this.getReplicationStatus = options?.getReplicationStatus;
+    this.getClusterStatus = options?.getClusterStatus;
+    this.wsHandler = new WSHandler(sirannon, { resolveExecutionTarget: this.resolveExecutionTarget });
     this.app = uWS.App();
     this.registerRoutes();
   }
@@ -628,15 +810,15 @@ var SirannonServer = class {
       });
     });
   }
-  close() {
-    return new Promise((resolve) => {
-      this.wsHandler.close();
+  async close() {
+    try {
+      await this.wsHandler.close();
+    } finally {
       if (this.listenSocket) {
         uWS.us_listen_socket_close(this.listenSocket);
         this.listenSocket = null;
       }
-      resolve();
-    });
+    }
   }
   get listeningPort() {
     if (!this.listenSocket) return -1;
@@ -655,10 +837,14 @@ var SirannonServer = class {
       });
     }
     this.app.get("/health", this.withCors(handleLiveness()));
-    this.app.get("/health/ready", this.withCors(handleReadiness(this.sirannon)));
-    this.app.post("/db/:id/query", this.wrapDbRoute(handleQuery(this.sirannon)));
-    this.app.post("/db/:id/execute", this.wrapDbRoute(handleExecute(this.sirannon)));
-    this.app.post("/db/:id/transaction", this.wrapDbRoute(handleTransaction(this.sirannon)));
+    this.app.get("/health/ready", this.withCors(handleReadiness(this.sirannon, this.getReplicationStatus)));
+    this.app.get("/db/:id/cluster", this.wrapDbGetRoute(handleClusterStatus(this.getClusterStatus)));
+    this.app.post("/db/:id/query", this.wrapDbRoute(handleQuery(this.sirannon, this.resolveExecutionTarget)));
+    this.app.post("/db/:id/execute", this.wrapDbRoute(handleExecute(this.sirannon, this.resolveExecutionTarget)));
+    this.app.post(
+      "/db/:id/transaction",
+      this.wrapDbRoute(handleTransaction(this.sirannon, this.resolveExecutionTarget))
+    );
     this.registerWebSocketRoute();
     this.app.any("/*", (res) => {
       sendError(res, 404, "NOT_FOUND", "Route not found");
@@ -677,6 +863,7 @@ var SirannonServer = class {
         const method = req.getMethod();
         const secWebSocketKey = req.getHeader("sec-websocket-key");
         const secWebSocketProtocol = req.getHeader("sec-websocket-protocol");
+        const selectedWebSocketProtocol = selectWebSocketProtocol(secWebSocketProtocol);
         const secWebSocketExtensions = req.getHeader("sec-websocket-extensions");
         const headers = {};
         req.forEach((key, value) => {
@@ -692,7 +879,7 @@ var SirannonServer = class {
             res.upgrade(
               { databaseId: dbId },
               secWebSocketKey,
-              secWebSocketProtocol,
+              selectedWebSocketProtocol,
               secWebSocketExtensions,
               context
             );
@@ -711,7 +898,7 @@ var SirannonServer = class {
           res.upgrade(
             { databaseId: dbId },
             secWebSocketKey,
-            secWebSocketProtocol,
+            selectedWebSocketProtocol,
             secWebSocketExtensions,
             context
           );
@@ -735,7 +922,8 @@ var SirannonServer = class {
           }
         };
         userData.conn = conn;
-        wsHandler.handleOpen(conn, userData.databaseId);
+        wsHandler.handleOpen(conn, userData.databaseId).catch(() => {
+        });
       },
       message: (ws, message) => {
         const userData = ws.getUserData();
@@ -773,9 +961,15 @@ var SirannonServer = class {
       const abort = initAbortHandler(res);
       const bodyPromise = readBody(res, MAX_BODY, abort);
       if (!onRequestHook) {
-        bodyPromise.then((rawBody) => {
+        bodyPromise.then(async (rawBody) => {
           if (abort.aborted) return;
-          handler(res, dbId, rawBody);
+          try {
+            await handler(res, dbId, rawBody, abort);
+          } catch {
+            if (!abort.aborted) {
+              sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
+            }
+          }
         }).catch(() => {
         });
         return;
@@ -793,9 +987,48 @@ var SirannonServer = class {
         remoteAddress
       };
       const hookPromise = runOnRequest(res, ctx, onRequestHook);
-      Promise.all([bodyPromise, hookPromise]).then(([rawBody, allowed]) => {
+      Promise.all([bodyPromise, hookPromise]).then(async ([rawBody, allowed]) => {
         if (abort.aborted || !allowed) return;
-        handler(res, dbId, rawBody);
+        try {
+          await handler(res, dbId, rawBody, abort);
+        } catch {
+          if (!abort.aborted) {
+            sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
+          }
+        }
+      }).catch(() => {
+      });
+    };
+  }
+  wrapDbGetRoute(handler) {
+    const onRequestHook = this.onRequestHook;
+    const corsHeaders = this.cors;
+    return (res, req) => {
+      const dbId = req.getParameter(0) ?? "";
+      const method = req.getMethod();
+      const path = req.getUrl();
+      if (corsHeaders) {
+        writeCorsOrigin(res, corsHeaders, req.getHeader("origin"));
+      }
+      if (!onRequestHook) {
+        handler(res, dbId);
+        return;
+      }
+      const headers = {};
+      req.forEach((key, value) => {
+        headers[key] = value;
+      });
+      const ctx = {
+        headers,
+        method,
+        path,
+        databaseId: dbId,
+        remoteAddress: decodeRemoteAddress(res)
+      };
+      runOnRequest(res, ctx, onRequestHook).then((allowed) => {
+        if (allowed) {
+          handler(res, dbId);
+        }
       }).catch(() => {
       });
     };