@rpcbase/server 0.464.0 → 0.466.0

package/dist/checkInitReplicaSet.d.ts

@@ -0,0 +1,6 @@
+type ServerEnv = {
+    [key: string]: string | undefined;
+};
+export declare const checkInitReplicaSet: (serverEnv: ServerEnv) => Promise<void>;
+export {};
+//# sourceMappingURL=checkInitReplicaSet.d.ts.map

package/dist/checkInitReplicaSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkInitReplicaSet.d.ts","sourceRoot":"","sources":["../src/checkInitReplicaSet.ts"],"names":[],"mappings":"AAGA,KAAK,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAMtD,eAAO,MAAM,mBAAmB,GAAU,WAAW,SAAS,KAAG,OAAO,CAAC,IAAI,CAiH5E,CAAA"}

package/dist/index-BXODFGBH.js

@@ -0,0 +1,490 @@
+import { randomUUID } from "node:crypto";
+import { loadModel } from "@rpcbase/db";
+import { WebSocketServer } from "ws";
+const TENANT_ID_QUERY_PARAM = "rb-tenant-id";
+const USER_ID_HEADER = "rb-user-id";
+const QUERY_KEY_MAX_LEN = 4096;
+const QUERY_MAX_LIMIT = 4096;
+const initializedServers = /* @__PURE__ */ new WeakSet();
+const customHandlers = [];
+const sockets = /* @__PURE__ */ new Map();
+const socketMeta = /* @__PURE__ */ new Map();
+const socketWrappers = /* @__PURE__ */ new Map();
+const socketCleanup = /* @__PURE__ */ new Map();
+const socketSubscriptions = /* @__PURE__ */ new Map();
+const subscriptions = /* @__PURE__ */ new Map();
+const changeStreams = /* @__PURE__ */ new Map();
+class RtsSocket {
+  id;
+  tenantId;
+  userId;
+  ws;
+  handlers = /* @__PURE__ */ new Map();
+  constructor({
+    id,
+    ws,
+    meta
+  }) {
+    this.id = id;
+    this.ws = ws;
+    this.tenantId = meta.tenantId;
+    this.userId = meta.userId;
+  }
+  on(event, handler) {
+    const set = this.handlers.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.handlers.set(event, set);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (!set) return;
+    set.delete(handler);
+    if (!set.size) this.handlers.delete(event);
+  }
+  emit(event, payload) {
+    sendWs(this.ws, { type: "event", event, payload });
+  }
+  close() {
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+  dispatch(event, payload) {
+    const set = this.handlers.get(event);
+    if (!set) return;
+    for (const handler of set) {
+      handler(payload);
+    }
+  }
+}
+const rawToText = (raw) => {
+  if (typeof raw === "string") return raw;
+  if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString();
+  if (Array.isArray(raw)) return Buffer.concat(raw).toString();
+  return raw.toString();
+};
+const safeJsonParse = (raw) => JSON.parse(rawToText(raw));
+const sendWs = (ws, message) => {
+  if (ws.readyState !== 1) return;
+  ws.send(JSON.stringify(message));
+};
+const unauthorized = (socket, message = "Unauthorized") => {
+  try {
+    socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+    socket.write(`Error: ${message}\r
+`);
+    socket.end();
+  } catch {
+    socket.destroy();
+  }
+};
+const badRequest = (socket, message = "Bad Request") => {
+  try {
+    socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+    socket.write(`Error: ${message}\r
+`);
+    socket.end();
+  } catch {
+    socket.destroy();
+  }
+};
+const runSessionMiddleware = async (sessionMiddleware, req) => {
+  await new Promise((resolve, reject) => {
+    sessionMiddleware(req, {}, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+};
+const parseUpgradeMeta = async ({
+  req,
+  url,
+  sessionMiddleware
+}) => {
+  const tenantId = url.searchParams.get(TENANT_ID_QUERY_PARAM);
+  if (!tenantId) {
+    throw new Error("Missing rb-tenant-id query parameter");
+  }
+  const raw = req.headers[USER_ID_HEADER];
+  const headerUserId = Array.isArray(raw) ? raw[0] : raw;
+  if (headerUserId) return { tenantId, userId: headerUserId };
+  if (!sessionMiddleware) {
+    throw new Error("Missing rb-user-id header (reverse-proxy) and no session middleware configured");
+  }
+  const upgradeReq = req;
+  try {
+    await runSessionMiddleware(sessionMiddleware, upgradeReq);
+  } catch {
+    throw new Error("Failed to load session for RTS");
+  }
+  const sessionUser = upgradeReq.session?.user;
+  const sessionUserId = sessionUser?.id;
+  if (!sessionUserId) {
+    throw new Error("Not signed in (missing session.user.id)");
+  }
+  const signedInTenants = sessionUser?.signed_in_tenants;
+  const currentTenantId = sessionUser?.current_tenant_id;
+  if (Array.isArray(signedInTenants) && signedInTenants.length > 0) {
+    if (!signedInTenants.includes(tenantId)) {
+      throw new Error("Tenant not authorized for this session");
+    }
+  } else if (currentTenantId) {
+    if (currentTenantId !== tenantId) {
+      throw new Error("Tenant not authorized for this session");
+    }
+  } else {
+    throw new Error("Tenant not authorized for this session");
+  }
+  return { tenantId, userId: sessionUserId };
+};
+const getTenantModel = async (tenantId, modelName) => {
+  const ctx = {
+    req: {
+      session: {
+        user: {
+          current_tenant_id: tenantId
+        }
+      }
+    }
+  };
+  return loadModel(modelName, ctx);
+};
+const normalizeLimit = (limit) => {
+  if (typeof limit !== "number") return QUERY_MAX_LIMIT;
+  if (!Number.isFinite(limit)) return QUERY_MAX_LIMIT;
+  return Math.min(QUERY_MAX_LIMIT, Math.abs(limit));
+};
+const normalizeOptions = (options) => {
+  if (!options || typeof options !== "object") return {};
+  const normalized = {};
+  if (options.projection && typeof options.projection === "object") {
+    normalized.projection = options.projection;
+  }
+  if (options.sort && typeof options.sort === "object") {
+    normalized.sort = options.sort;
+  }
+  normalized.limit = normalizeLimit(options.limit);
+  return normalized;
+};
+const runAndSendQuery = async ({
+  tenantId,
+  targetSocketIds,
+  modelName,
+  queryKey,
+  query,
+  options
+}) => {
+  const model = await getTenantModel(tenantId, modelName);
+  const projection = options.projection ?? void 0;
+  const sort = options.sort;
+  const limit = normalizeLimit(options.limit);
+  const queryPromise = model.find(query, projection);
+  if (sort && Object.keys(sort).length) {
+    queryPromise.sort(sort);
+  }
+  queryPromise.limit(limit);
+  const data = await queryPromise;
+  const payload = { type: "query_payload", modelName, queryKey, data };
+  for (const socketId of targetSocketIds) {
+    const ws = sockets.get(socketId);
+    if (!ws) continue;
+    sendWs(ws, payload);
+  }
+};
+const dispatchSubscriptionsForModel = async (tenantId, modelName) => {
+  const tenantSubs = subscriptions.get(tenantId);
+  const modelSubs = tenantSubs?.get(modelName);
+  if (!modelSubs || !modelSubs.size) return;
+  for (const [queryKey, sub] of modelSubs.entries()) {
+    const targetSocketIds = Array.from(sub.socketIds);
+    if (!targetSocketIds.length) continue;
+    try {
+      await runAndSendQuery({
+        tenantId,
+        targetSocketIds,
+        modelName,
+        queryKey,
+        query: sub.query,
+        options: sub.options
+      });
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error";
+      const payload = { type: "query_payload", modelName, queryKey, error };
+      for (const socketId of targetSocketIds) {
+        const ws = sockets.get(socketId);
+        if (!ws) continue;
+        sendWs(ws, payload);
+      }
+    }
+  }
+};
+const ensureChangeStream = async (tenantId, modelName) => {
+  const tenantStreams = changeStreams.get(tenantId) ?? /* @__PURE__ */ new Map();
+  changeStreams.set(tenantId, tenantStreams);
+  if (tenantStreams.has(modelName)) return;
+  const model = await getTenantModel(tenantId, modelName);
+  const stream = model.watch([], {
+    fullDocument: "updateLookup"
+  });
+  stream.on("change", () => {
+    void dispatchSubscriptionsForModel(tenantId, modelName);
+  });
+  stream.on("close", () => {
+    const map = changeStreams.get(tenantId);
+    map?.delete(modelName);
+    if (map && map.size === 0) changeStreams.delete(tenantId);
+  });
+  stream.on("error", () => {
+    try {
+      stream.close();
+    } catch {
+    }
+  });
+  tenantStreams.set(modelName, stream);
+};
+const addSocketSubscription = ({
+  socketId,
+  tenantId,
+  modelName,
+  queryKey,
+  query,
+  options
+}) => {
+  const tenantSubs = subscriptions.get(tenantId) ?? /* @__PURE__ */ new Map();
+  subscriptions.set(tenantId, tenantSubs);
+  const modelSubs = tenantSubs.get(modelName) ?? /* @__PURE__ */ new Map();
+  tenantSubs.set(modelName, modelSubs);
+  const existing = modelSubs.get(queryKey);
+  if (existing) {
+    existing.socketIds.add(socketId);
+  } else {
+    modelSubs.set(queryKey, {
+      query,
+      options,
+      socketIds: /* @__PURE__ */ new Set([socketId])
+    });
+  }
+  const byModel = socketSubscriptions.get(socketId) ?? /* @__PURE__ */ new Map();
+  socketSubscriptions.set(socketId, byModel);
+  const querySet = byModel.get(modelName) ?? /* @__PURE__ */ new Set();
+  byModel.set(modelName, querySet);
+  querySet.add(queryKey);
+};
+const removeSocketSubscription = ({
+  socketId,
+  tenantId,
+  modelName,
+  queryKey
+}) => {
+  const tenantSubs = subscriptions.get(tenantId);
+  const modelSubs = tenantSubs?.get(modelName);
+  const sub = modelSubs?.get(queryKey);
+  if (sub) {
+    sub.socketIds.delete(socketId);
+    if (!sub.socketIds.size) {
+      modelSubs?.delete(queryKey);
+    }
+  }
+  const byModel = socketSubscriptions.get(socketId);
+  const set = byModel?.get(modelName);
+  if (set) {
+    set.delete(queryKey);
+    if (!set.size) {
+      byModel?.delete(modelName);
+    }
+  }
+  if (modelSubs && modelSubs.size === 0) {
+    tenantSubs?.delete(modelName);
+    const tenantStreams = changeStreams.get(tenantId);
+    const stream = tenantStreams?.get(modelName);
+    if (stream) {
+      try {
+        stream.close();
+      } catch {
+      }
+      tenantStreams?.delete(modelName);
+      if (tenantStreams && tenantStreams.size === 0) changeStreams.delete(tenantId);
+    }
+  }
+  if (tenantSubs && tenantSubs.size === 0) subscriptions.delete(tenantId);
+  if (byModel && byModel.size === 0) socketSubscriptions.delete(socketId);
+};
+const cleanupSocket = (socketId) => {
+  const meta = socketMeta.get(socketId);
+  if (meta) {
+    const byModel = socketSubscriptions.get(socketId);
+    if (byModel) {
+      for (const [modelName, keys] of byModel.entries()) {
+        for (const queryKey of keys.values()) {
+          removeSocketSubscription({
+            socketId,
+            tenantId: meta.tenantId,
+            modelName,
+            queryKey
+          });
+        }
+      }
+    }
+  }
+  socketSubscriptions.delete(socketId);
+  const cleanupFns = socketCleanup.get(socketId) ?? [];
+  socketCleanup.delete(socketId);
+  for (const fn of cleanupFns) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  sockets.delete(socketId);
+  socketMeta.delete(socketId);
+  socketWrappers.delete(socketId);
+};
+const handleClientMessage = async ({
+  socketId,
+  meta,
+  message
+}) => {
+  const ws = sockets.get(socketId);
+  if (!ws) return;
+  if (message.type === "event") {
+    const wrapper = socketWrappers.get(socketId);
+    wrapper?.dispatch(message.event, message.payload);
+    return;
+  }
+  if (!message.modelName || typeof message.modelName !== "string") return;
+  if (!message.queryKey || typeof message.queryKey !== "string") return;
+  if (message.queryKey.length > QUERY_KEY_MAX_LEN) return;
+  if (message.type === "remove_query") {
+    removeSocketSubscription({
+      socketId,
+      tenantId: meta.tenantId,
+      modelName: message.modelName,
+      queryKey: message.queryKey
+    });
+    return;
+  }
+  if (!message.query || typeof message.query !== "object") return;
+  const options = normalizeOptions(message.options);
+  if (message.type === "registerQuery") {
+    addSocketSubscription({
+      socketId,
+      tenantId: meta.tenantId,
+      modelName: message.modelName,
+      queryKey: message.queryKey,
+      query: message.query,
+      options
+    });
+    try {
+      await ensureChangeStream(meta.tenantId, message.modelName);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unable to initialize change stream";
+      sendWs(ws, { type: "query_payload", modelName: message.modelName, queryKey: message.queryKey, error });
+      return;
+    }
+  }
+  try {
+    await runAndSendQuery({
+      tenantId: meta.tenantId,
+      targetSocketIds: [socketId],
+      modelName: message.modelName,
+      queryKey: message.queryKey,
+      query: message.query,
+      options
+    });
+  } catch (err) {
+    const error = err instanceof Error ? err.message : "Unknown error";
+    sendWs(ws, { type: "query_payload", modelName: message.modelName, queryKey: message.queryKey, error });
+  }
+};
+const initRts = ({
+  server,
+  path = "/rts",
+  sessionMiddleware
+}) => {
+  if (initializedServers.has(server)) return;
+  initializedServers.add(server);
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (req, socket, head) => {
+    let url;
+    try {
+      url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
+    } catch {
+      badRequest(socket, "Invalid URL");
+      return;
+    }
+    if (url.pathname !== path) return;
+    void (async () => {
+      try {
+        const meta = await parseUpgradeMeta({ req, url, sessionMiddleware });
+        req.__rb_rts_meta = meta;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          wss.emit("connection", ws, req);
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "RTS upgrade failed";
+        if (message.startsWith("Missing rb-tenant-id")) {
+          badRequest(socket, message);
+          return;
+        }
+        unauthorized(socket, message);
+        return;
+      }
+    })().catch(() => {
+      badRequest(socket, "RTS upgrade failed");
+    });
+  });
+  wss.on("connection", (ws, req) => {
+    const meta = req.__rb_rts_meta;
+    if (!meta) {
+      try {
+        ws.close();
+      } catch {
+      }
+      return;
+    }
+    const socketId = randomUUID();
+    sockets.set(socketId, ws);
+    socketMeta.set(socketId, meta);
+    const wrapper = new RtsSocket({ id: socketId, ws, meta });
+    socketWrappers.set(socketId, wrapper);
+    const cleanupFns = [];
+    for (const handler of customHandlers) {
+      try {
+        const cleanup = handler(wrapper);
+        if (typeof cleanup === "function") cleanupFns.push(cleanup);
+      } catch {
+      }
+    }
+    if (cleanupFns.length) socketCleanup.set(socketId, cleanupFns);
+    ws.on("message", (raw) => {
+      let parsed;
+      try {
+        parsed = safeJsonParse(raw);
+      } catch {
+        return;
+      }
+      if (!parsed || typeof parsed !== "object") return;
+      const message = parsed;
+      void handleClientMessage({ socketId, meta, message });
+    });
+    ws.on("close", () => {
+      cleanupSocket(socketId);
+    });
+    ws.on("error", () => {
+      cleanupSocket(socketId);
+    });
+  });
+};
+const registerRtsHandler = (handler) => {
+  customHandlers.push(handler);
+};
+const notifyRtsModelChanged = (tenantId, modelName) => {
+  void dispatchSubscriptionsForModel(tenantId, modelName);
+};
+export {
+  initRts as i,
+  notifyRtsModelChanged as n,
+  registerRtsHandler as r
+};

package/dist/index.d.ts

@@ -4,4 +4,5 @@ export * from './hashPassword';
 export * from './passwordHashStorage';
 export * from './ssrMiddleware';
 export * from './email';
+export * from './rts/index';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA"}

package/dist/index.js

@@ -2,6 +2,7 @@ import session from "express-session";
 import { RedisStore } from "connect-redis";
 import MongoStore from "connect-mongo";
 import { createClient } from "redis";
+import { MongoClient } from "mongodb";
 import env from "@rpcbase/env";
 import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
 import { dirname, posix, sep } from "path";
@@ -18,6 +19,7 @@ import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
 import { jsx } from "react/jsx-runtime";
 import { createPath, matchRoutes, parsePath, createStaticRouter, StaticRouterProvider } from "@rpcbase/router";
 import { Resend } from "resend";
+import { i, n, r } from "./index-BXODFGBH.js";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -93,9 +95,9 @@ function requireLib() {
       }
       return ip;
     });
-    for (var i = 0; i < forwardedIps.length; i++) {
-      if (is.ip(forwardedIps[i])) {
-        return forwardedIps[i];
+    for (var i2 = 0; i2 < forwardedIps.length; i2++) {
+      if (is.ip(forwardedIps[i2])) {
+        return forwardedIps[i2];
       }
     }
     return null;
@@ -206,8 +208,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? dirname(proces
     if (".js" === ext || ".mjs" === ext || ".cjs" === ext) file = file.slice(0, -1 * ext.length);
     const decodedFile = decodeURIComponent(file);
     if (!dir) dir = ".";
-    const n = dir.lastIndexOf("/node_modules");
-    if (n > -1) return `${dir.slice(n + 14).replace(/\//g, ".")}:${decodedFile}`;
+    const n2 = dir.lastIndexOf("/node_modules");
+    if (n2 > -1) return `${dir.slice(n2 + 14).replace(/\//g, ".")}:${decodedFile}`;
     if (dir.startsWith(normalizedBase)) {
       const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, ".");
       return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
@@ -334,12 +336,12 @@ class UUID {
     }
     if (hex) {
       const inner = new Uint8Array(16);
-      for (let i = 0; i < 16; i += 4) {
-        const n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
-        inner[i + 0] = n >>> 24;
-        inner[i + 1] = n >>> 16;
-        inner[i + 2] = n >>> 8;
-        inner[i + 3] = n;
+      for (let i2 = 0; i2 < 16; i2 += 4) {
+        const n2 = parseInt(hex.substring(2 * i2, 2 * i2 + 8), 16);
+        inner[i2 + 0] = n2 >>> 24;
+        inner[i2 + 1] = n2 >>> 16;
+        inner[i2 + 2] = n2 >>> 8;
+        inner[i2 + 3] = n2;
       }
       return new UUID(inner);
     }
@@ -347,18 +349,18 @@ class UUID {
   }
   toString() {
     let text = "";
-    for (let i = 0; i < this.bytes.length; i++) {
-      text += DIGITS.charAt(this.bytes[i] >>> 4);
-      text += DIGITS.charAt(15 & this.bytes[i]);
-      if (3 === i || 5 === i || 7 === i || 9 === i) text += "-";
+    for (let i2 = 0; i2 < this.bytes.length; i2++) {
+      text += DIGITS.charAt(this.bytes[i2] >>> 4);
+      text += DIGITS.charAt(15 & this.bytes[i2]);
+      if (3 === i2 || 5 === i2 || 7 === i2 || 9 === i2) text += "-";
     }
     return text;
   }
   toHex() {
     let text = "";
-    for (let i = 0; i < this.bytes.length; i++) {
-      text += DIGITS.charAt(this.bytes[i] >>> 4);
-      text += DIGITS.charAt(15 & this.bytes[i]);
+    for (let i2 = 0; i2 < this.bytes.length; i2++) {
+      text += DIGITS.charAt(this.bytes[i2] >>> 4);
+      text += DIGITS.charAt(15 & this.bytes[i2]);
     }
     return text;
   }
@@ -366,12 +368,12 @@ class UUID {
     return this.toString();
   }
   getVariant() {
-    const n = this.bytes[8] >>> 4;
-    if (n < 0) throw new Error("unreachable");
-    if (n <= 7) return this.bytes.every((e) => 0 === e) ? "NIL" : "VAR_0";
-    if (n <= 11) return "VAR_10";
-    if (n <= 13) return "VAR_110";
-    if (n <= 15) return this.bytes.every((e) => 255 === e) ? "MAX" : "VAR_RESERVED";
+    const n2 = this.bytes[8] >>> 4;
+    if (n2 < 0) throw new Error("unreachable");
+    if (n2 <= 7) return this.bytes.every((e) => 0 === e) ? "NIL" : "VAR_0";
+    if (n2 <= 11) return "VAR_10";
+    if (n2 <= 13) return "VAR_110";
+    if (n2 <= 15) return this.bytes.every((e) => 255 === e) ? "MAX" : "VAR_RESERVED";
     else throw new Error("unreachable");
   }
   getVersion() {
@@ -384,8 +386,8 @@ class UUID {
     return 0 === this.compareTo(other);
   }
   compareTo(other) {
-    for (let i = 0; i < 16; i++) {
-      const diff = this.bytes[i] - other.bytes[i];
+    for (let i2 = 0; i2 < 16; i2++) {
+      const diff = this.bytes[i2] - other.bytes[i2];
       if (0 !== diff) return Math.sign(diff);
     }
     return 0;
@@ -720,8 +722,8 @@ function removeTrailingSlash(url) {
 }
 async function retriable(fn, props) {
   let lastError = null;
-  for (let i = 0; i < props.retryCount + 1; i++) {
-    if (i > 0) await new Promise((r) => setTimeout(r, props.retryDelay));
+  for (let i2 = 0; i2 < props.retryCount + 1; i2++) {
+    if (i2 > 0) await new Promise((r2) => setTimeout(r2, props.retryDelay));
     try {
       const res = await fn();
       return res;
@@ -1423,8 +1425,8 @@ function getFilenameToChunkIdMap(stackParser) {
     if (result) acc[result[0]] = result[1];
     else {
       const parsedStack = stackParser(stackKey);
-      for (let i = parsedStack.length - 1; i >= 0; i--) {
-        const stackFrame = parsedStack[i];
+      for (let i2 = parsedStack.length - 1; i2 >= 0; i2--) {
+        const stackFrame = parsedStack[i2];
         const filename = stackFrame?.filename;
         const chunkId = chunkIdMap[stackKey];
         if (filename && chunkId) {
@@ -1632,8 +1634,8 @@ function createStackParser(platform, ...parsers) {
   return (stack, skipFirstLines = 0) => {
     const frames = [];
     const lines = stack.split("\n");
-    for (let i = skipFirstLines; i < lines.length; i++) {
-      const line = lines[i];
+    for (let i2 = skipFirstLines; i2 < lines.length; i2++) {
+      const line = lines[i2];
       if (line.length > 1024) continue;
       const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
       if (!cleanedLine.match(/\S*Error: /)) {
@@ -1715,10 +1717,10 @@ function extractExceptionKeysForMessage(err, maxLength = 40) {
   const keys = Object.keys(err);
   keys.sort();
   if (!keys.length) return "[object has no keys]";
-  for (let i = keys.length; i > 0; i--) {
-    const serialized = keys.slice(0, i).join(", ");
+  for (let i2 = keys.length; i2 > 0; i2--) {
+    const serialized = keys.slice(0, i2).join(", ");
     if (!(serialized.length > maxLength)) {
-      if (i === keys.length) return serialized;
+      if (i2 === keys.length) return serialized;
       return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
     }
   }
@@ -1827,8 +1829,8 @@ const MAX_CONTEXTLINES_COLNO = 1e3;
 const MAX_CONTEXTLINES_LINENO = 1e4;
 async function addSourceContext(frames) {
   const filesToLines = {};
-  for (let i = frames.length - 1; i >= 0; i--) {
-    const frame = frames[i];
+  for (let i2 = frames.length - 1; i2 >= 0; i2--) {
+    const frame = frames[i2];
     const filename = frame?.filename;
     if (!frame || "string" != typeof filename || "number" != typeof frame.lineno || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) continue;
     const filesToLinesOutput = filesToLines[filename];
@@ -1844,7 +1846,7 @@ async function addSourceContext(frames) {
     if (!filesToLineRanges) continue;
     filesToLineRanges.sort((a, b) => a - b);
     const ranges = makeLineReaderRanges(filesToLineRanges);
-    if (ranges.every((r) => rangeExistsInContentCache(file, r))) continue;
+    if (ranges.every((r2) => rangeExistsInContentCache(file, r2))) continue;
     const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
     readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
   }
@@ -1912,8 +1914,8 @@ function addSourceContextToFrames(frames, cache) {
 function addContextToFrame(lineno, frame, contents) {
   if (void 0 === frame.lineno || void 0 === contents) return;
   frame.pre_context = [];
-  for (let i = makeRangeStart(lineno); i < lineno; i++) {
-    const line = contents[i];
+  for (let i2 = makeRangeStart(lineno); i2 < lineno; i2++) {
+    const line = contents[i2];
     if (void 0 === line) return void clearLineContext(frame);
     frame.pre_context.push(line);
   }
@@ -1921,8 +1923,8 @@ function addContextToFrame(lineno, frame, contents) {
   frame.context_line = contents[lineno];
   const end = makeRangeEnd(lineno);
   frame.post_context = [];
-  for (let i = lineno + 1; i <= end; i++) {
-    const line = contents[i];
+  for (let i2 = lineno + 1; i2 <= end; i2++) {
+    const line = contents[i2];
     if (void 0 === line) break;
     frame.post_context.push(line);
   }
@@ -1943,29 +1945,29 @@ function shouldSkipContextLinesForFrame(frame) {
 function rangeExistsInContentCache(file, range) {
   const contents = LRU_FILE_CONTENTS_CACHE.get(file);
   if (void 0 === contents) return false;
-  for (let i = range[0]; i <= range[1]; i++) if (void 0 === contents[i]) return false;
+  for (let i2 = range[0]; i2 <= range[1]; i2++) if (void 0 === contents[i2]) return false;
   return true;
 }
 function makeLineReaderRanges(lines) {
   if (!lines.length) return [];
-  let i = 0;
+  let i2 = 0;
   const line = lines[0];
   if ("number" != typeof line) return [];
   let current = makeContextRange(line);
   const out = [];
   while (true) {
-    if (i === lines.length - 1) {
+    if (i2 === lines.length - 1) {
       out.push(current);
       break;
     }
-    const next = lines[i + 1];
+    const next = lines[i2 + 1];
     if ("number" != typeof next) break;
     if (next <= current[1]) current[1] = next + DEFAULT_LINES_OF_CONTEXT;
     else {
       out.push(current);
       current = makeContextRange(next);
     }
-    i++;
+    i2++;
   }
   return out;
 }
@@ -3277,6 +3279,101 @@ const metricsIngestProxyMiddleware = (app) => {
     })
   );
 };
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+let hasWarnedNoReplicationEnabled = false;
+const checkInitReplicaSet = async (serverEnv) => {
+  const port = serverEnv.DB_PORT?.trim();
+  if (!port) return;
+  const host = (serverEnv.DB_HOST ?? "localhost").trim();
+  const replSetName = "rs0";
+  const memberHost = `${host}:${port}`;
+  const maxAttempts = 10;
+  const serverSelectionTimeoutMs = 2e3;
+  const uri = `mongodb://${host}:${port}/?directConnection=true`;
+  const waitForReplicaSetReady = async (admin) => {
+    const maxWaitAttempts = 10;
+    for (let attempt = 1; attempt <= maxWaitAttempts; attempt++) {
+      try {
+        const status = await admin.command({ replSetGetStatus: 1 });
+        const state = Number(status?.myState ?? 0);
+        if (status?.ok && (state === 1 || state === 2)) return;
+      } catch {
+      }
+      await sleep(250 * attempt);
+    }
+  };
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    let client2 = null;
+    try {
+      client2 = new MongoClient(uri, {
+        family: 4,
+        serverSelectionTimeoutMS: serverSelectionTimeoutMs,
+        connectTimeoutMS: serverSelectionTimeoutMs
+      });
+      await client2.connect();
+      const admin = client2.db("admin").admin();
+      await admin.command({ ping: 1 });
+      try {
+        await admin.command({ replSetGetStatus: 1 });
+        return;
+      } catch (error) {
+        const codeName = error?.codeName;
+        if (codeName === "NotYetInitialized") {
+          try {
+            const res = await admin.command({
+              replSetInitiate: {
+                _id: replSetName,
+                members: [{ _id: 0, host: memberHost }]
+              }
+            });
+            if (res?.ok) {
+              console.warn(`[rb/server] MongoDB replica set '${replSetName}' initiated (${memberHost}).`);
+            } else {
+              console.warn(`[rb/server] MongoDB replica set initiation returned ok=${String(res?.ok)}.`);
+            }
+          } catch (initError) {
+            const initCodeName = initError?.codeName;
+            if (initCodeName !== "AlreadyInitialized") {
+              const message2 = initError instanceof Error ? initError.message : String(initError);
+              console.warn(`[rb/server] MongoDB replica set initiation failed: ${message2}`);
+              if (initCodeName === "InvalidReplicaSetConfig") {
+                console.warn(
+                  `[rb/server] Hint: the replica set member host must match the mongod address/port. If MongoDB runs in Docker with port mapping, ensure the container listens on ${port} (e.g. mongod --port ${port}) instead of the default 27017.`
+                );
+              }
+            }
+          }
+          await waitForReplicaSetReady(admin);
+          return;
+        }
+        if (codeName === "NoReplicationEnabled") {
+          if (!hasWarnedNoReplicationEnabled) {
+            hasWarnedNoReplicationEnabled = true;
+            console.warn(
+              `[rb/server] MongoDB is not started with --replSet ${replSetName} (replication disabled). Change streams require a replica set; start mongod with --replSet.`
+            );
+          }
+          return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[rb/server] MongoDB replica set check failed: ${message}`);
+        return;
+      }
+    } catch (error) {
+      if (attempt === maxAttempts) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[rb/server] MongoDB replica set auto-init skipped (unable to connect to ${host}:${port}): ${message}`);
+        return;
+      }
+      await sleep(250 * attempt);
+    } finally {
+      try {
+        await client2?.close();
+      } catch {
+      }
+    }
+  }
+};
 process.env = {
   ...env,
   ...__rb_env__,
@@ -3296,17 +3393,24 @@ const getMongoUrl = (serverEnv) => {
   }
   return void 0;
 };
-const createMongoSessionStore = (serverEnv) => {
+const createMongoSessionStore = async (serverEnv) => {
   const mongoUrl = getMongoUrl(serverEnv);
   if (!mongoUrl) {
     throw new Error("Missing REDIS_URL and Mongo connection details (MONGODB_URL/MONGO_URL/MONGODB_URI/DB_PORT)");
   }
   console.log("Using MongoDB session store");
-  return MongoStore.create({
-    mongoUrl,
+  const client2 = await MongoClient.connect(mongoUrl, {
+    family: 4,
+    serverSelectionTimeoutMS: 2e3,
+    connectTimeoutMS: 2e3
+  });
+  const store = MongoStore.create({
+    client: client2,
     collectionName: "sessions",
     ttl: SESSION_MAX_AGE_S
   });
+  await store.collectionP;
+  return store;
 };
 const createRedisSessionStore = async (redisUrl) => {
   const reconnectStrategy = (retries) => {
@@ -3341,6 +3445,10 @@ const createRedisSessionStore = async (redisUrl) => {
 };
 const initServer = async (app, serverEnv) => {
   await initApiClient({ app });
+  const replicaSetInitPromise = checkInitReplicaSet(serverEnv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[rb/server] MongoDB replica set auto-init error: ${message}`);
+  });
   app.disable("x-powered-by");
   app.set("trust proxy", true);
   app.use(requestIp.mw());
@@ -3363,7 +3471,13 @@ const initServer = async (app, serverEnv) => {
   }
   const sessionSecret = getDerivedKey(serverEnv.MASTER_KEY, "express_session_key");
   const redisUrl = serverEnv.REDIS_URL?.trim();
-  const store = redisUrl ? await createRedisSessionStore(redisUrl) : createMongoSessionStore(serverEnv);
+  let store;
+  if (redisUrl) {
+    store = await createRedisSessionStore(redisUrl);
+  } else {
+    await replicaSetInitPromise;
+    store = await createMongoSessionStore(serverEnv);
+  }
   const sessionConfig = {
     name: "session",
     store,
@@ -3378,7 +3492,9 @@ const initServer = async (app, serverEnv) => {
   if (isProduction$1) {
     sessionConfig.cookie.secure = true;
   }
-  app.use(session(sessionConfig));
+  const sessionMiddleware = session(sessionConfig);
+  app.locals.rbSessionMiddleware = sessionMiddleware;
+  app.use(sessionMiddleware);
 };
 async function hashPassword(password, salt) {
   const keyLength = 64;
@@ -3422,15 +3538,15 @@ const parseEnvInt = (value) => {
   return parsed;
 };
 const isPowerOfTwo = (value) => (value & value - 1) === 0;
-const estimateScryptMemoryBytes = ({ N, r, p }) => {
-  return 128 * r * (N + p);
+const estimateScryptMemoryBytes = ({ N, r: r2, p }) => {
+  return 128 * r2 * (N + p);
 };
 const validateScryptParams = (params) => {
-  const { N, r, p, keylen, saltBytes, maxmemBytes } = params;
+  const { N, r: r2, p, keylen, saltBytes, maxmemBytes } = params;
   if (!Number.isSafeInteger(N) || N < 2 || N > MAX_SCRYPT_N || !isPowerOfTwo(N)) {
     return { ok: false, error: "invalid_scrypt_N" };
   }
-  if (!Number.isSafeInteger(r) || r < 1 || r > MAX_SCRYPT_R) {
+  if (!Number.isSafeInteger(r2) || r2 < 1 || r2 > MAX_SCRYPT_R) {
     return { ok: false, error: "invalid_scrypt_r" };
   }
   if (!Number.isSafeInteger(p) || p < 1 || p > MAX_SCRYPT_P) {
@@ -3445,7 +3561,7 @@ const validateScryptParams = (params) => {
   if (!Number.isSafeInteger(maxmemBytes) || maxmemBytes < 16 * 1024 * 1024 || maxmemBytes > MAX_SCRYPT_MAXMEM_BYTES) {
     return { ok: false, error: "invalid_scrypt_maxmem" };
   }
-  const estimatedMem = estimateScryptMemoryBytes({ N, r, p });
+  const estimatedMem = estimateScryptMemoryBytes({ N, r: r2, p });
   if (estimatedMem > maxmemBytes) {
     return { ok: false, error: "scrypt_params_exceed_maxmem" };
   }
@@ -3480,9 +3596,9 @@ const getCurrentScryptParams = (opts) => {
   return params;
 };
 const scryptAsync = async (password, salt, params) => {
-  const { N, r, p, keylen, maxmemBytes } = params;
+  const { N, r: r2, p, keylen, maxmemBytes } = params;
   return await new Promise((resolve, reject) => {
-    crypto.scrypt(password, salt, keylen, { N, r, p, maxmem: maxmemBytes }, (err, derivedKey) => {
+    crypto.scrypt(password, salt, keylen, { N, r: r2, p, maxmem: maxmemBytes }, (err, derivedKey) => {
       if (err) {
         reject(err);
         return;
@@ -3529,10 +3645,10 @@ const parseStoredScryptHash = (stored) => {
     params.set(key, value);
   }
   const N = params.get("N");
-  const r = params.get("r");
+  const r2 = params.get("r");
   const p = params.get("p");
   const keylen = params.get("keylen");
-  if (N === void 0 || r === void 0 || p === void 0 || keylen === void 0) return null;
+  if (N === void 0 || r2 === void 0 || p === void 0 || keylen === void 0) return null;
   if (params.size !== 4) return null;
   const salt = parseB64(saltB64);
   const dk = parseB64(dkB64);
@@ -3543,31 +3659,31 @@ const parseStoredScryptHash = (stored) => {
   const currentMaxmemBytes = getCurrentMaxmemBytes();
   const validated = validateScryptParams({
     N,
-    r,
+    r: r2,
     p,
     keylen,
     saltBytes: salt.length,
     maxmemBytes: currentMaxmemBytes
   });
   if (!validated.ok) return null;
-  return { N, r, p, keylen, salt, dk };
+  return { N, r: r2, p, keylen, salt, dk };
 };
 async function hashPasswordForStorage(password, opts) {
-  const { N, r, p, keylen, saltBytes, maxmemBytes } = getCurrentScryptParams(opts);
+  const { N, r: r2, p, keylen, saltBytes, maxmemBytes } = getCurrentScryptParams(opts);
   const salt = crypto.randomBytes(saltBytes);
-  const dk = await scryptAsync(password, salt, { N, r, p, keylen, maxmemBytes });
+  const dk = await scryptAsync(password, salt, { N, r: r2, p, keylen, maxmemBytes });
   const saltB64 = salt.toString("base64");
   const dkB64 = dk.toString("base64");
-  return `$scrypt$N=${N},r=${r},p=${p},keylen=${keylen}$${saltB64}$${dkB64}`;
+  return `$scrypt$N=${N},r=${r2},p=${p},keylen=${keylen}$${saltB64}$${dkB64}`;
 }
 async function verifyPasswordFromStorage(password, stored) {
   const parsed = parseStoredScryptHash(stored);
   if (!parsed) return false;
-  const { N, r, p, keylen, salt, dk } = parsed;
+  const { N, r: r2, p, keylen, salt, dk } = parsed;
   const maxmemBytes = getCurrentMaxmemBytes();
   let derivedKey;
   try {
-    derivedKey = await scryptAsync(password, salt, { N, r, p, keylen, maxmemBytes });
+    derivedKey = await scryptAsync(password, salt, { N, r: r2, p, keylen, maxmemBytes });
   } catch {
     return false;
   }
@@ -3590,7 +3706,7 @@ function createLocation(current, to, state = null, key) {
   return location;
 }
 function getShortCircuitMatches(routes) {
-  const route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || {
+  const route = routes.length === 1 ? routes[0] : routes.find((r2) => r2.index || !r2.path || r2.path === "/") || {
     id: "__shim-error-route__"
   };
   return {
@@ -4095,7 +4211,10 @@ export {
   getDerivedKey,
   hashPassword,
   hashPasswordForStorage,
+  i as initRts,
   initServer,
+  n as notifyRtsModelChanged,
+  r as registerRtsHandler,
   sendEmail,
   ssrMiddleware,
   verifyPasswordFromStorage

package/dist/initServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initServer.d.ts","sourceRoot":"","sources":["../src/initServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAuBrC,KAAK,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AA8EtD,eAAO,MAAM,UAAU,GAAU,KAAK,WAAW,EAAE,WAAW,SAAS,kBA2DtE,CAAA"}
+{"version":3,"file":"initServer.d.ts","sourceRoot":"","sources":["../src/initServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAyBrC,KAAK,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAuFtD,eAAO,MAAM,UAAU,GAAU,KAAK,WAAW,EAAE,WAAW,SAAS,kBAsEtE,CAAA"}

package/dist/rts/index.d.ts

@@ -0,0 +1,34 @@
+import { Server as HttpServer } from 'node:http';
+import { RequestHandler } from 'express';
+import { WebSocket } from 'ws';
+type SocketMeta = {
+    tenantId: string;
+    userId: string;
+};
+type HandlerFn = (socket: RtsSocket) => void | (() => void);
+declare class RtsSocket {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly userId: string;
+    private readonly ws;
+    private readonly handlers;
+    constructor({ id, ws, meta, }: {
+        id: string;
+        ws: WebSocket;
+        meta: SocketMeta;
+    });
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    off(event: string, handler: (payload: unknown) => void): void;
+    emit(event: string, payload?: unknown): void;
+    close(): void;
+    dispatch(event: string, payload: unknown): void;
+}
+export declare const initRts: ({ server, path, sessionMiddleware, }: {
+    server: HttpServer;
+    path?: string;
+    sessionMiddleware?: RequestHandler;
+}) => void;
+export declare const registerRtsHandler: (handler: HandlerFn) => void;
+export declare const notifyRtsModelChanged: (tenantId: string, modelName: string) => void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/rts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rts/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAA;AAGtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAG7C,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,IAAI,CAAA;AAqBlE,KAAK,UAAU,GAAG;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAoBD,KAAK,SAAS,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAA;AAoB3D,cAAM,SAAS;IACb,SAAgB,EAAE,EAAE,MAAM,CAAA;IAC1B,SAAgB,QAAQ,EAAE,MAAM,CAAA;IAChC,SAAgB,MAAM,EAAE,MAAM,CAAA;IAE9B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqD;gBAE3D,EACjB,EAAE,EACF,EAAE,EACF,IAAI,GACL,EAAE;QACD,EAAE,EAAE,MAAM,CAAA;QACV,EAAE,EAAE,SAAS,CAAA;QACb,IAAI,EAAE,UAAU,CAAA;KACjB;IAOM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI;IAOlE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAO7D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAI5C,KAAK,IAAI,IAAI;IAQb,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;CAOvD;AA4aD,eAAO,MAAM,OAAO,GAAI,sCAIrB;IACD,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iBAAiB,CAAC,EAAE,cAAc,CAAA;CACnC,KAAG,IAyFH,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,SAAS,SAAS,KAAG,IAEvD,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,UAAU,MAAM,EAAE,WAAW,MAAM,KAAG,IAE3E,CAAA"}

package/dist/rts.d.ts

@@ -0,0 +1,2 @@
+export * from './rts/index';
+//# sourceMappingURL=rts.d.ts.map

package/dist/rts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rts.d.ts","sourceRoot":"","sources":["../src/rts.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/dist/rts.js

@@ -0,0 +1,6 @@
+import { i, n, r } from "./index-BXODFGBH.js";
+export {
+  i as initRts,
+  n as notifyRtsModelChanged,
+  r as registerRtsHandler
+};

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "@rpcbase/server",
-  "version": "0.464.0",
+  "version": "0.466.0",
   "type": "module",
   "files": [
     "dist"
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./rts": {
+      "types": "./dist/rts.d.ts",
+      "import": "./dist/rts.js",
+      "default": "./dist/rts.js"
+    }
+  },
   "scripts": {
     "build": "wireit",
     "test": "wireit",
@@ -63,10 +75,13 @@
     "connect-redis": "9.0.0",
     "express-session": "1.18.2",
     "http-proxy-middleware": "3.0.5",
+    "mongodb": "7.0.0",
     "redis": "5.10.0",
-    "resend": "6.5.2"
+    "resend": "6.5.2",
+    "ws": "8.18.0"
   },
   "devDependencies": {
+    "@types/ws": "8.18.1",
     "request-ip": "3.3.0"
   }
 }