@delali/sirannon-db 0.1.1

package/dist/server/index.mjs

@@ -0,0 +1,808 @@
+import { ChangeTracker, SubscriptionManager, SirannonError } from '../chunk-VI4UP4RR.mjs';
+import uWS from 'uWebSockets.js';
+import SqliteDatabase from 'better-sqlite3';
+
+// src/server/protocol.ts
+function toExecuteResponse(result) {
+  return {
+    changes: result.changes,
+    lastInsertRowId: typeof result.lastInsertRowId === "bigint" ? result.lastInsertRowId.toString() : result.lastInsertRowId
+  };
+}
+
+// src/server/health.ts
+function handleLiveness() {
+  const payload = JSON.stringify({ status: "ok" });
+  return (res) => {
+    res.cork(() => {
+      res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
+    });
+  };
+}
+function handleReadiness(sirannon) {
+  return (res) => {
+    const dbs = sirannon.databases();
+    const databases = [];
+    let degraded = false;
+    for (const [id, db] of dbs) {
+      const entry = {
+        id,
+        readOnly: db.readOnly,
+        closed: db.closed
+      };
+      databases.push(entry);
+      if (db.closed) degraded = true;
+    }
+    const body = {
+      status: degraded ? "degraded" : "ok",
+      databases
+    };
+    const payload = JSON.stringify(body);
+    res.cork(() => {
+      res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
+    });
+  };
+}
+
+// src/server/http-handler.ts
+function initAbortHandler(res) {
+  const listeners = [];
+  let aborted = false;
+  res.onAborted(() => {
+    aborted = true;
+    for (const fn of listeners) fn();
+  });
+  return {
+    get aborted() {
+      return aborted;
+    },
+    onAbort(fn) {
+      if (aborted) {
+        fn();
+      } else {
+        listeners.push(fn);
+      }
+    }
+  };
+}
+function readBody(res, maxBytes, abort) {
+  return new Promise((resolve, reject) => {
+    if (abort.aborted) {
+      reject(new Error("Request aborted"));
+      return;
+    }
+    let done = false;
+    const chunks = [];
+    let totalLength = 0;
+    abort.onAbort(() => {
+      if (done) return;
+      done = true;
+      reject(new Error("Request aborted"));
+    });
+    res.onData((chunk, isLast) => {
+      if (done || abort.aborted) return;
+      totalLength += chunk.byteLength;
+      if (totalLength > maxBytes) {
+        done = true;
+        if (!abort.aborted) {
+          sendError(res, 413, "PAYLOAD_TOO_LARGE", "Request body exceeds size limit");
+        }
+        reject(new Error("Payload too large"));
+        return;
+      }
+      chunks.push(Buffer.from(chunk));
+      if (isLast) {
+        done = true;
+        resolve(Buffer.concat(chunks));
+      }
+    });
+  });
+}
+function parseBody(res, raw) {
+  if (raw.length === 0) {
+    sendError(res, 400, "EMPTY_BODY", "Request body is empty");
+    return null;
+  }
+  try {
+    return JSON.parse(raw.toString("utf-8"));
+  } catch {
+    sendError(res, 400, "INVALID_JSON", "Request body is not valid JSON");
+    return null;
+  }
+}
+function sendJson(res, data) {
+  const payload = JSON.stringify(data);
+  res.cork(() => {
+    res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
+  });
+}
+function sendError(res, status, code, message) {
+  const body = { error: { code, message } };
+  const payload = JSON.stringify(body);
+  res.cork(() => {
+    res.writeStatus(`${status}`).writeHeader("Content-Type", "application/json").end(payload);
+  });
+}
+function httpStatusForError(err) {
+  switch (err.code) {
+    case "DATABASE_NOT_FOUND":
+      return 404;
+    case "READ_ONLY":
+      return 403;
+    case "QUERY_ERROR":
+    case "TRANSACTION_ERROR":
+      return 400;
+    case "HOOK_DENIED":
+      return 403;
+    case "DATABASE_CLOSED":
+    case "SHUTDOWN":
+      return 503;
+    default:
+      return 500;
+  }
+}
+function resolveDatabase(res, sirannon, id) {
+  const db = sirannon.get(id);
+  if (!db) {
+    sendError(res, 404, "DATABASE_NOT_FOUND", `Database '${id}' not found`);
+    return null;
+  }
+  return db;
+}
+function handleQuery(sirannon) {
+  return (res, dbId, rawBody) => {
+    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;
+    try {
+      const rows = db.query(body.sql, body.params);
+      sendJson(res, { rows });
+    } catch (err) {
+      if (err instanceof SirannonError) {
+        sendError(res, httpStatusForError(err), err.code, err.message);
+      } else {
+        sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
+      }
+    }
+  };
+}
+function handleExecute(sirannon) {
+  return (res, dbId, rawBody) => {
+    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;
+    try {
+      const result = db.execute(body.sql, body.params);
+      sendJson(res, toExecuteResponse(result));
+    } catch (err) {
+      if (err instanceof SirannonError) {
+        sendError(res, httpStatusForError(err), err.code, err.message);
+      } else {
+        sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
+      }
+    }
+  };
+}
+function handleTransaction(sirannon) {
+  return (res, dbId, rawBody) => {
+    const body = parseBody(res, rawBody);
+    if (!body) return;
+    if (!Array.isArray(body.statements)) {
+      sendError(res, 400, "INVALID_REQUEST", 'Field "statements" is required and must be an array');
+      return;
+    }
+    if (body.statements.length === 0) {
+      sendError(res, 400, "INVALID_REQUEST", "Transaction requires at least one statement");
+      return;
+    }
+    for (let i = 0; i < body.statements.length; i++) {
+      const stmt = body.statements[i];
+      if (!stmt.sql || typeof stmt.sql !== "string") {
+        sendError(res, 400, "INVALID_REQUEST", `Statement at index ${i} is missing a valid "sql" field`);
+        return;
+      }
+    }
+    const db = resolveDatabase(res, sirannon, dbId);
+    if (!db) return;
+    try {
+      const results = db.transaction((tx) => {
+        return body.statements.map((stmt) => tx.execute(stmt.sql, stmt.params));
+      });
+      sendJson(res, {
+        results: results.map(toExecuteResponse)
+      });
+    } catch (err) {
+      if (err instanceof SirannonError) {
+        sendError(res, httpStatusForError(err), err.code, err.message);
+      } else {
+        sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
+      }
+    }
+  };
+}
+var DEFAULT_POLL_INTERVAL_MS = 50;
+var DEFAULT_MAX_PAYLOAD_LENGTH = 1048576;
+var WSHandler = class {
+  sirannon;
+  maxPayloadLength;
+  connections = /* @__PURE__ */ new Map();
+  cdcContexts = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(sirannon, options) {
+    this.sirannon = sirannon;
+    this.maxPayloadLength = options?.maxPayloadLength ?? DEFAULT_MAX_PAYLOAD_LENGTH;
+  }
+  // --- 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) {
+    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);
+    if (!database) {
+      this.sendError(conn, "", "DATABASE_NOT_FOUND", `Database '${databaseId}' not found`);
+      conn.close(1008, "Database not found");
+      return;
+    }
+    if (database.closed) {
+      this.sendError(conn, "", "DATABASE_CLOSED", `Database '${databaseId}' is closed`);
+      conn.close(1008, "Database closed");
+      return;
+    }
+    this.connections.set(conn, {
+      databaseId,
+      database,
+      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;
+    if (data.length > this.maxPayloadLength) {
+      this.sendError(conn, "", "PAYLOAD_TOO_LARGE", "Message exceeds maximum payload length");
+      return;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      this.sendError(conn, "", "INVALID_JSON", "Failed to parse message as JSON");
+      return;
+    }
+    if (typeof msg !== "object" || msg === null || Array.isArray(msg)) {
+      this.sendError(conn, "", "INVALID_MESSAGE", "Message must be a JSON object");
+      return;
+    }
+    if (typeof msg.type !== "string") {
+      this.sendError(conn, "", "INVALID_MESSAGE", 'Message must have a string "type" field');
+      return;
+    }
+    if (typeof msg.id !== "string") {
+      this.sendError(conn, "", "INVALID_MESSAGE", 'Message must have a string "id" field');
+      return;
+    }
+    const id = msg.id;
+    switch (msg.type) {
+      case "query":
+        this.handleQuery(conn, state, msg, id);
+        break;
+      case "execute":
+        this.handleExecute(conn, state, msg, id);
+        break;
+      case "subscribe":
+        this.handleSubscribe(conn, state, msg, id);
+        break;
+      case "unsubscribe":
+        this.handleUnsubscribe(conn, state, id);
+        break;
+      default:
+        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;
+    for (const sub of state.subscriptions.values()) {
+      sub.unsubscribe();
+    }
+    state.subscriptions.clear();
+    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() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const [conn, state] of this.connections) {
+      for (const sub of state.subscriptions.values()) {
+        sub.unsubscribe();
+      }
+      state.subscriptions.clear();
+      conn.close(1001, "Handler shutting down");
+    }
+    this.connections.clear();
+    for (const ctx of this.cdcContexts.values()) {
+      ctx.stopPolling();
+      try {
+        ctx.cdcDb.close();
+      } catch {
+      }
+    }
+    this.cdcContexts.clear();
+  }
+  // --- Private message handlers ---
+  handleQuery(conn, state, msg, id) {
+    if (typeof msg.sql !== "string") {
+      this.sendError(conn, id, "INVALID_MESSAGE", 'Query message requires a "sql" string field');
+      return;
+    }
+    if (!this.isValidParams(msg.params)) {
+      this.sendError(conn, id, "INVALID_MESSAGE", '"params" must be an object or array');
+      return;
+    }
+    try {
+      const params = msg.params ?? void 0;
+      const rows = state.database.query(msg.sql, params);
+      this.send(conn, { type: "result", id, data: { rows } });
+    } catch (err) {
+      this.sendSirannonError(conn, id, err);
+    }
+  }
+  handleExecute(conn, state, msg, id) {
+    if (typeof msg.sql !== "string") {
+      this.sendError(conn, id, "INVALID_MESSAGE", 'Execute message requires a "sql" string field');
+      return;
+    }
+    if (!this.isValidParams(msg.params)) {
+      this.sendError(conn, id, "INVALID_MESSAGE", '"params" must be an object or array');
+      return;
+    }
+    try {
+      const params = msg.params ?? void 0;
+      const result = state.database.execute(msg.sql, params);
+      this.send(conn, {
+        type: "result",
+        id,
+        data: toExecuteResponse(result)
+      });
+    } catch (err) {
+      this.sendSirannonError(conn, id, err);
+    }
+  }
+  handleSubscribe(conn, state, msg, id) {
+    if (typeof msg.table !== "string") {
+      this.sendError(conn, id, "INVALID_MESSAGE", 'Subscribe message requires a "table" string field');
+      return;
+    }
+    if (state.subscriptions.has(id)) {
+      this.sendError(conn, id, "DUPLICATE_SUBSCRIPTION", `Subscription '${id}' already exists on this connection`);
+      return;
+    }
+    if (state.database.readOnly) {
+      this.sendError(conn, id, "READ_ONLY", "Subscriptions are not available on read-only databases");
+      return;
+    }
+    if (state.database.path === ":memory:") {
+      this.sendError(conn, id, "CDC_UNSUPPORTED", "CDC subscriptions require file-based databases");
+      return;
+    }
+    if (msg.filter !== void 0 && msg.filter !== null && (typeof msg.filter !== "object" || Array.isArray(msg.filter))) {
+      this.sendError(conn, id, "INVALID_MESSAGE", '"filter" must be a plain object');
+      return;
+    }
+    const filter = msg.filter ?? void 0;
+    try {
+      const ctx = this.ensureCDC(state.databaseId, state.database);
+      ctx.tracker.watch(ctx.cdcDb, 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) {
+      this.sendSirannonError(conn, id, err);
+    }
+  }
+  handleUnsubscribe(conn, state, id) {
+    const sub = state.subscriptions.get(id);
+    if (!sub) {
+      this.sendError(conn, id, "SUBSCRIPTION_NOT_FOUND", `Subscription '${id}' not found`);
+      return;
+    }
+    sub.unsubscribe();
+    state.subscriptions.delete(id);
+    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) {
+    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 tracker = new ChangeTracker();
+    const manager = new SubscriptionManager();
+    let consecutiveErrors = 0;
+    const MAX_CONSECUTIVE_ERRORS = 10;
+    const stopPolling = () => {
+      clearInterval(interval);
+    };
+    const tick = () => {
+      if (manager.size === 0) return;
+      try {
+        const events = tracker.poll(cdcDb);
+        if (events.length > 0) {
+          manager.dispatch(events);
+        }
+        consecutiveErrors = 0;
+      } catch {
+        consecutiveErrors++;
+        if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+          stopPolling();
+        }
+      }
+    };
+    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.
+   */
+  maybeCleanupCDC(databaseId) {
+    const ctx = this.cdcContexts.get(databaseId);
+    if (!ctx || ctx.manager.size > 0) return;
+    ctx.stopPolling();
+    try {
+      ctx.cdcDb.close();
+    } catch {
+    }
+    this.cdcContexts.delete(databaseId);
+  }
+  // --- Validation ---
+  isValidParams(params) {
+    if (params === void 0 || params === null) return true;
+    return typeof params === "object";
+  }
+  // --- Send helpers ---
+  send(conn, msg) {
+    try {
+      conn.send(JSON.stringify(msg));
+    } catch {
+    }
+  }
+  sendError(conn, id, code, message) {
+    this.send(conn, { type: "error", id, error: { code, message } });
+  }
+  sendSirannonError(conn, id, err) {
+    const code = err instanceof SirannonError ? err.code : "INTERNAL_ERROR";
+    const message = err instanceof SirannonError ? err.message : "An unexpected error occurred";
+    this.sendError(conn, id, code, message);
+  }
+  sendChange(conn, subscriptionId, event) {
+    this.send(conn, {
+      type: "change",
+      id: subscriptionId,
+      event: {
+        type: event.type,
+        table: event.table,
+        row: event.row,
+        oldRow: event.oldRow,
+        seq: event.seq.toString(),
+        timestamp: event.timestamp
+      }
+    });
+  }
+};
+function createWSHandler(sirannon, options) {
+  return new WSHandler(sirannon, options);
+}
+
+// src/server/server.ts
+function resolveCors(cors) {
+  if (!cors) return null;
+  if (cors === true) {
+    return {
+      origin: "*",
+      methods: "GET, POST, OPTIONS",
+      headers: "Content-Type, Authorization"
+    };
+  }
+  return {
+    origin: cors.origin ?? "*",
+    methods: cors.methods?.join(", ") ?? "GET, POST, OPTIONS",
+    headers: cors.headers?.join(", ") ?? "Content-Type, Authorization"
+  };
+}
+function matchOrigin(cors, requestOrigin) {
+  if (cors.origin === "*") return "*";
+  if (typeof cors.origin === "string") return cors.origin;
+  if (cors.origin.includes(requestOrigin)) return requestOrigin;
+  return null;
+}
+function writeCorsOrigin(res, cors, requestOrigin) {
+  const allowed = matchOrigin(cors, requestOrigin);
+  if (!allowed) return;
+  res.writeHeader("Access-Control-Allow-Origin", allowed);
+  if (allowed !== "*") {
+    res.writeHeader("Vary", "Origin");
+  }
+}
+function decodeRemoteAddress(res) {
+  return Buffer.from(res.getRemoteAddressAsText()).toString();
+}
+function isRequestDenial(value) {
+  return typeof value === "object" && value !== null && "status" in value;
+}
+async function runOnRequest(res, ctx, hook) {
+  try {
+    const result = await hook(ctx);
+    if (isRequestDenial(result)) {
+      sendError(res, result.status, result.code, result.message);
+      return false;
+    }
+    return true;
+  } catch {
+    sendError(res, 500, "HOOK_ERROR", "onRequest hook threw an error");
+    return false;
+  }
+}
+var SirannonServer = class {
+  app;
+  listenSocket = null;
+  host;
+  port;
+  cors;
+  onRequestHook;
+  sirannon;
+  wsHandler;
+  constructor(sirannon, options) {
+    this.sirannon = sirannon;
+    this.host = options?.host ?? "127.0.0.1";
+    this.port = options?.port ?? 9876;
+    this.cors = resolveCors(options?.cors);
+    this.onRequestHook = options?.onRequest;
+    this.wsHandler = new WSHandler(sirannon);
+    this.app = uWS.App();
+    this.registerRoutes();
+  }
+  listen() {
+    return new Promise((resolve, reject) => {
+      this.app.listen(this.host, this.port, (socket) => {
+        if (socket) {
+          this.listenSocket = socket;
+          resolve();
+        } else {
+          reject(new Error(`Failed to listen on ${this.host}:${this.port}`));
+        }
+      });
+    });
+  }
+  close() {
+    return new Promise((resolve) => {
+      this.wsHandler.close();
+      if (this.listenSocket) {
+        uWS.us_listen_socket_close(this.listenSocket);
+        this.listenSocket = null;
+      }
+      resolve();
+    });
+  }
+  get listeningPort() {
+    if (!this.listenSocket) return -1;
+    return uWS.us_socket_local_port(this.listenSocket);
+  }
+  registerRoutes() {
+    if (this.cors) {
+      const cors = this.cors;
+      this.app.options("/*", (res, req) => {
+        const requestOrigin = req.getHeader("origin");
+        res.cork(() => {
+          res.writeStatus("204 No Content");
+          writeCorsOrigin(res, cors, requestOrigin);
+          res.writeHeader("Access-Control-Allow-Methods", cors.methods).writeHeader("Access-Control-Allow-Headers", cors.headers).writeHeader("Access-Control-Max-Age", "86400").endWithoutBody();
+        });
+      });
+    }
+    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.registerWebSocketRoute();
+    this.app.any("/*", (res) => {
+      sendError(res, 404, "NOT_FOUND", "Route not found");
+    });
+  }
+  registerWebSocketRoute() {
+    const wsHandler = this.wsHandler;
+    const onRequestHook = this.onRequestHook;
+    this.app.ws("/db/:id", {
+      maxPayloadLength: 1048576,
+      idleTimeout: 120,
+      sendPingsAutomatically: true,
+      upgrade: (res, req, context) => {
+        const dbId = req.getParameter(0) ?? "";
+        const url = req.getUrl();
+        const method = req.getMethod();
+        const secWebSocketKey = req.getHeader("sec-websocket-key");
+        const secWebSocketProtocol = req.getHeader("sec-websocket-protocol");
+        const secWebSocketExtensions = req.getHeader("sec-websocket-extensions");
+        const headers = {};
+        req.forEach((key, value) => {
+          headers[key] = value;
+        });
+        const remoteAddress = decodeRemoteAddress(res);
+        let aborted = false;
+        res.onAborted(() => {
+          aborted = true;
+        });
+        if (!onRequestHook) {
+          if (!aborted) {
+            res.upgrade(
+              { databaseId: dbId },
+              secWebSocketKey,
+              secWebSocketProtocol,
+              secWebSocketExtensions,
+              context
+            );
+          }
+          return;
+        }
+        const ctx = {
+          headers,
+          method,
+          path: url,
+          databaseId: dbId,
+          remoteAddress
+        };
+        runOnRequest(res, ctx, onRequestHook).then((allowed) => {
+          if (aborted || !allowed) return;
+          res.upgrade(
+            { databaseId: dbId },
+            secWebSocketKey,
+            secWebSocketProtocol,
+            secWebSocketExtensions,
+            context
+          );
+        }).catch(() => {
+        });
+      },
+      open: (ws) => {
+        const userData = ws.getUserData();
+        const conn = {
+          send(data) {
+            try {
+              ws.send(data, false);
+            } catch {
+            }
+          },
+          close(code, reason) {
+            try {
+              ws.end(code, reason);
+            } catch {
+            }
+          }
+        };
+        userData.conn = conn;
+        wsHandler.handleOpen(conn, userData.databaseId);
+      },
+      message: (ws, message) => {
+        const userData = ws.getUserData();
+        if (!userData.conn) return;
+        const text = Buffer.from(message).toString("utf-8");
+        wsHandler.handleMessage(userData.conn, text);
+      },
+      close: (ws) => {
+        const userData = ws.getUserData();
+        if (!userData.conn) return;
+        wsHandler.handleClose(userData.conn);
+        userData.conn = void 0;
+      }
+    });
+  }
+  withCors(handler) {
+    if (!this.cors) return handler;
+    const cors = this.cors;
+    return (res, req) => {
+      writeCorsOrigin(res, cors, req.getHeader("origin"));
+      handler(res, req);
+    };
+  }
+  wrapDbRoute(handler) {
+    const onRequestHook = this.onRequestHook;
+    const corsHeaders = this.cors;
+    const MAX_BODY = 1048576;
+    return (res, req) => {
+      const dbId = req.getParameter(0) ?? "";
+      const method = req.getMethod();
+      const path = req.getUrl();
+      if (corsHeaders) {
+        writeCorsOrigin(res, corsHeaders, req.getHeader("origin"));
+      }
+      const abort = initAbortHandler(res);
+      const bodyPromise = readBody(res, MAX_BODY, abort);
+      if (!onRequestHook) {
+        bodyPromise.then((rawBody) => {
+          if (abort.aborted) return;
+          handler(res, dbId, rawBody);
+        }).catch(() => {
+        });
+        return;
+      }
+      const headers = {};
+      req.forEach((key, value) => {
+        headers[key] = value;
+      });
+      const remoteAddress = decodeRemoteAddress(res);
+      const ctx = {
+        headers,
+        method,
+        path,
+        databaseId: dbId,
+        remoteAddress
+      };
+      const hookPromise = runOnRequest(res, ctx, onRequestHook);
+      Promise.all([bodyPromise, hookPromise]).then(([rawBody, allowed]) => {
+        if (abort.aborted || !allowed) return;
+        handler(res, dbId, rawBody);
+      }).catch(() => {
+      });
+    };
+  }
+};
+function createServer(sirannon, options) {
+  return new SirannonServer(sirannon, options);
+}
+
+export { SirannonServer, WSHandler, createServer, createWSHandler, toExecuteResponse };