@pluv/io 0.40.2 → 0.41.1

package/dist/index.mjs

@@ -202,28 +202,12 @@ var AbstractWebSocket = class {
     this.CLOSING = 2;
     /** The connection is closed. */
     this.CLOSED = 3;
-    this._user = null;
     const { persistence, platform, room } = config;
     this.persistence = persistence;
     this._platform = platform;
     this.room = room;
     this.webSocket = webSocket;
   }
-  getSession() {
-    return __async(this, null, function* () {
-      var _a;
-      const sessionId = this.sessionId;
-      const state = this.state;
-      const room = state.room;
-      const user = (_a = this._user) != null ? _a : yield this.persistence.getUser(room, sessionId);
-      this._user = user;
-      return __spreadProps(__spreadValues({}, state), {
-        id: sessionId,
-        user,
-        webSocket: this
-      });
-    });
-  }
   handleError(params) {
     var _a, _b, _c;
     const { error, message: _message, room, session } = params;
@@ -361,14 +345,19 @@ import { noop } from "@pluv/crdt";
 import colors from "kleur";
 
 // src/constants.ts
+var GARBAGE_COLLECT_INTERVAL_MS = 6e4;
+var MAX_PRESENCE_SIZE_BYTES = 512;
+var MAX_USER_SIZE_BYTES = 512;
 var PING_TIMEOUT_MS = 3e4;
 
 // src/IORoom.ts
 var IORoom = class {
   constructor(id, config) {
+    this._lastGarbageCollectMs = -1 * (GARBAGE_COLLECT_INTERVAL_MS + 1);
     this._uninitialize = null;
     this._authorize = null;
     this._sessions = /* @__PURE__ */ new Map();
+    this._userSessionss = /* @__PURE__ */ new Map();
     const {
       _meta,
       authorize: authorize2,
@@ -398,12 +387,15 @@ var IORoom = class {
     if (authorize2) this._authorize = authorize2;
     const webSockets = this._platform.getWebSockets();
     webSockets.forEach((webSocket) => {
+      var _a;
       const deserialized = this._platform.getSerializedState(webSocket);
       const sessionId = this._platform.getSessionId(webSocket);
       if (!deserialized) return;
       if (typeof sessionId !== "string") return;
       const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
       this._sessions.set(sessionId, pluvWs);
+      const userId = (_a = pluvWs.session.user) == null ? void 0 : _a.id;
+      if (!!userId) this._addUserSession(userId, sessionId);
     });
     const { doc, uninitialize } = this._initialize();
     this._doc = doc;
@@ -461,6 +453,16 @@ var IORoom = class {
       yield this._emitQuitters();
     });
   }
+  /**
+   * @description The IORoom will garbage collect occasionally as connections ping/pong the
+   * server
+   */
+  garbageCollect() {
+    return __async(this, null, function* () {
+      this._lastGarbageCollectMs = Date.now();
+      this._emitQuitters();
+    });
+  }
   getSize() {
     const currentTime = (/* @__PURE__ */ new Date()).getTime();
     return Array.from(this._sessions.values()).reduce((count, pluvWs) => {
@@ -509,19 +511,25 @@ var IORoom = class {
       const user = yield this._getAuthorizedUser(token, _options);
       const ioAuthorize = this._getIOAuthorize(_options);
       const isUnauthorized = !!ioAuthorize && !user;
-      const isTokenInUse = !!user && (yield this._getSessions().then((sessions) => sessions.some((session) => {
-        var _a2;
-        return ((_a2 = session.user) == null ? void 0 : _a2.id) === user.id;
-      })));
       const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
-      this._logDebug(`${colors.blue(`Registering connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
-      yield this._platform.acceptWebSocket(pluvWs);
-      if (isUnauthorized || isTokenInUse) {
-        this._logDebug(`${colors.blue("Authorization failed for connection:")} ${pluvWs.sessionId}`);
+      if (isUnauthorized) {
+        this._logDebug(`${colors.blue("Authorization failed for connection")}`);
         pluvWs.handleError({ error: new Error("Not authorized"), room: this.id });
         pluvWs.close(3e3, "WebSocket unauthorized.");
         return;
       }
+      if (!!user) {
+        const latest = this._getLatestPresence(user.id);
+        const prevState = pluvWs.state;
+        pluvWs.user = user;
+        this._platform.setSerializedState(pluvWs, __spreadProps(__spreadValues({}, prevState), {
+          presence: latest.presence,
+          timers: __spreadProps(__spreadValues({}, prevState.timers), { presence: latest.timer })
+        }));
+        this._addUserSession(user.id, pluvWs.sessionId);
+      }
+      this._logDebug(`${colors.blue(`Registering connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
+      yield this._platform.acceptWebSocket(pluvWs);
       this._sessions.set(pluvWs.sessionId, pluvWs);
       yield this._platform.persistence.addUser(this.id, pluvWs.sessionId, user != null ? user : {});
       if (this._platform._config.registrationMode === "attached") {
@@ -532,17 +540,24 @@ var IORoom = class {
         pluvWs.addEventListener("message", onMessage);
       }
       yield this._emitRegistered(pluvWs);
-      this._logDebug(`${colors.blue(`Registered connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
       const size = this.getSize();
+      this._logDebug(`${colors.blue(`Registered connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
       this._logDebug(`${colors.blue(`Room ${this.id} size:`)} ${size}`);
     });
   }
+  _addUserSession(userId, sessionId) {
+    var _a;
+    const set = (_a = this._userSessionss.get(userId)) != null ? _a : /* @__PURE__ */ new Set();
+    const updated = set.add(sessionId);
+    this._userSessionss.set(userId, updated);
+    return updated;
+  }
   _broadcast(params) {
     return __async(this, null, function* () {
       var _a, _b, _c;
       const { message, senderId } = params;
       const sender = senderId ? (_a = this._sessions.get(senderId)) != null ? _a : null : null;
-      const session = (_b = yield sender == null ? void 0 : sender.getSession()) != null ? _b : null;
+      const session = (_b = sender == null ? void 0 : sender.session) != null ? _b : null;
       const user = (_c = session == null ? void 0 : session.user) != null ? _c : null;
       if (typeof senderId !== "string") return;
       this._platform.pubSub.publish(this.id, __spreadValues({
@@ -564,15 +579,18 @@ var IORoom = class {
           message: { type: "$exit", data: { sessionId } },
           senderId: sessionId
         });
+        const session = webSocket.session;
+        const user = session.user;
+        if (!!user) this._removeUserSession(user.id, sessionId);
         try {
-          const [session, doc] = yield Promise.all([webSocket.getSession(), this._doc]);
+          const doc = yield this._doc;
           const encodedState = doc.getEncodedState();
           yield Promise.resolve(
             this._listeners.onUserDisconnected({
               context: this._context,
               encodedState,
               room: this.id,
-              user: session.user
+              user
             })
           );
         } catch (error) {
@@ -603,10 +621,21 @@ var IORoom = class {
   }
   _emitRegistered(pluvWs) {
     return __async(this, null, function* () {
-      const session = yield pluvWs.getSession();
+      const session = pluvWs.session;
       const sessionId = session.id;
+      const presence = session.presence;
       const user = session.user;
-      yield this._sendSelfMessage({ type: "$registered", data: { sessionId } }, { sessionId, user });
+      yield this._sendSelfMessage(
+        {
+          type: "$registered",
+          data: {
+            presence,
+            sessionId,
+            timers: { presence: session.timers.presence }
+          }
+        },
+        { sessionId, user }
+      );
       try {
         const doc = yield this._doc;
         const encodedState = doc.getEncodedState();
@@ -681,6 +710,27 @@ var IORoom = class {
     if (typeof this._authorize === "function") return this._authorize(options);
     return this._authorize;
   }
+  _getLatestPresence(userId) {
+    var _a, _b;
+    if (!this._authorize) return { timer: null, presence: null };
+    const sessionIds = Array.from((_b = (_a = this._userSessionss.get(userId)) == null ? void 0 : _a.values()) != null ? _b : []);
+    if (!sessionIds.length) return { timer: null, presence: null };
+    return sessionIds.reduce(
+      (state, sessionId) => {
+        var _a2, _b2;
+        const pluvWs = (_a2 = this._sessions.get(sessionId)) != null ? _a2 : null;
+        if (!pluvWs) return state;
+        const session = pluvWs.session;
+        const presence = session.presence;
+        const timer = session.timers.presence;
+        if (((_b2 = session.user) == null ? void 0 : _b2.id) !== userId) return state;
+        if (typeof state.timer !== "number") return { presence, timer };
+        if (typeof timer !== "number") return state;
+        return timer > state.timer ? { presence, timer } : state;
+      },
+      { presence: null, timer: null }
+    );
+  }
   _getProcedure(message) {
     var _a;
     return (_a = this._router._defs.events[message.type]) != null ? _a : null;
@@ -691,19 +741,13 @@ var IORoom = class {
     return procedure.config.input ? procedure.config.input.parse(message.data) : message.data;
   }
   _getSession(webSocket) {
-    return __async(this, null, function* () {
-      const pluvWs = this._getAbstractWs(webSocket);
-      if (!pluvWs) throw new Error("Session could not be found");
-      return yield pluvWs.getSession();
-    });
+    const pluvWs = this._getAbstractWs(webSocket);
+    if (!pluvWs) throw new Error("Session could not be found");
+    return pluvWs.session;
   }
   _getSessions() {
-    return __async(this, null, function* () {
-      const promises = Array.from(this._sessions.values()).map((pluvWs) => __async(this, null, function* () {
-        return yield pluvWs.getSession();
-      }));
-      return yield Promise.all(promises);
-    });
+    const sessions = Array.from(this._sessions.values()).map((pluvWs) => pluvWs.session);
+    return sessions;
   }
   _initialize() {
     const promise = (() => __async(this, null, function* () {
@@ -776,17 +820,31 @@ var IORoom = class {
       if (!(yield this._initialized)) return;
       const pluvWs = this._getAbstractWs(webSocket);
       if (!pluvWs) throw new Error("Could not get session");
-      const [session, sessions] = yield Promise.all([
-        this._getSession(pluvWs),
-        this._getSessions()
-      ]);
+      const session = this._getSession(pluvWs);
+      const sessions = this._getSessions();
+      const setPresence = (params) => {
+        this._setPresence.bind(this)(params);
+      };
       const doc = yield this._doc;
       const eventContext = {
         context: this._context,
         doc,
+        garbageCollect: () => __async(this, null, function* () {
+          yield this.garbageCollect();
+        }),
+        get presence() {
+          return session.presence;
+        },
+        set presence(presence) {
+          var _a2;
+          const sessionId2 = (_a2 = this.session) == null ? void 0 : _a2.id;
+          if (!sessionId2) return;
+          setPresence({ presence, sessionId: sessionId2, timer: this.time });
+        },
         room: this.id,
         session,
-        sessions
+        sessions,
+        time: (/* @__PURE__ */ new Date()).getTime()
       };
       if (pluvWs.state.quit) {
         yield this._closeWebSockets([pluvWs]).catch(() => null);
@@ -832,22 +890,20 @@ var IORoom = class {
       ]).then((_0) => __async(this, [_0], function* ([broadcast, self, sync]) {
         const handleBroadcast = () => __async(this, null, function* () {
           if (!broadcast) return;
-          yield Promise.all(
-            Object.entries(broadcast).map((_02) => __async(this, [_02], function* ([type, data]) {
-              yield this._broadcast({
-                message: { data, type },
-                senderId: sessionId
-              });
-            }))
-          );
+          const messages = Object.entries(broadcast).map((_02) => __async(this, [_02], function* ([type, data]) {
+            yield this._broadcast({
+              message: { data, type },
+              senderId: sessionId
+            });
+          }));
+          yield Promise.all(messages);
         });
         const handleSelf = () => __async(this, null, function* () {
           if (!self) return;
-          yield Promise.all(
-            Object.entries(self).map((_02) => __async(this, [_02], function* ([type, data]) {
-              yield this._sendSelfMessage({ data, type }, { sessionId, user });
-            }))
-          );
+          const messages = Object.entries(self).map((_02) => __async(this, [_02], function* ([type, data]) {
+            yield this._sendSelfMessage({ data, type }, { sessionId, user });
+          }));
+          yield Promise.all(messages);
         });
         const handleSync = () => __async(this, null, function* () {
           if (!sync) return;
@@ -857,11 +913,10 @@ var IORoom = class {
             room: this.id,
             user
           }, message));
-          yield Promise.all(
-            Object.entries(sync).map((_02) => __async(this, [_02], function* ([type, data]) {
-              yield this._sendSelfMessage({ data, type }, { sessionId, user });
-            }))
-          );
+          const messages = Object.entries(sync).map((_02) => __async(this, [_02], function* ([type, data]) {
+            yield this._sendSelfMessage({ data, type }, { sessionId, user });
+          }));
+          yield Promise.all(messages);
         });
         yield Promise.all([handleBroadcast(), handleSelf(), handleSync()]);
       }));
@@ -878,6 +933,36 @@ var IORoom = class {
       return null;
     }
   }
+  _setPresence(params) {
+    var _a, _b;
+    const { presence, sessionId, timer: _timer } = params;
+    const timer = _timer != null ? _timer : (/* @__PURE__ */ new Date()).getTime();
+    const pluvWs = (_a = this._sessions.get(sessionId)) != null ? _a : null;
+    if (!pluvWs) return;
+    const wsSession = pluvWs.session;
+    const user = wsSession.user;
+    const sessionIds = user ? /* @__PURE__ */ new Set([...(_b = this._userSessionss.get(user.id)) != null ? _b : [], sessionId]) : /* @__PURE__ */ new Set([sessionId]);
+    sessionIds.forEach((sId) => {
+      const pWs = this._sessions.get(sId);
+      const session = pWs == null ? void 0 : pWs.session;
+      if (!session) return;
+      const prevState = session.webSocket.state;
+      this._platform.setSerializedState(session.webSocket, __spreadProps(__spreadValues({}, prevState), {
+        presence,
+        timers: __spreadProps(__spreadValues({}, prevState.timers), {
+          presence: timer
+        })
+      }));
+    });
+  }
+  _removeUserSession(userId, sessionId) {
+    const set = this._userSessionss.get(userId);
+    if (!set) return null;
+    set.delete(sessionId);
+    if (!!set.size) return set;
+    this._userSessionss.delete(userId);
+    return set;
+  }
   _sendMessage(pluvWs, message) {
     return __async(this, null, function* () {
       if (!(yield this._initialized)) return;
@@ -897,7 +982,7 @@ var IORoom = class {
       }, /* @__PURE__ */ new Map())) != null ? _b : this._sessions;
       const promises = Array.from(webSockets.values()).map((pluvWs) => __async(this, null, function* () {
         var _a2;
-        const session = yield pluvWs.getSession();
+        const session = pluvWs.session;
         const user = (_a2 = session.user) != null ? _a2 : null;
         this._sendMessage(pluvWs, { connectionId, data, room, type, user });
       }));
@@ -911,8 +996,13 @@ var IORoom = class {
       if (typeof senderId !== "string") return;
       const pluvWs = this._sessions.get(senderId);
       if (!pluvWs) return;
-      if (message.type === "$pong") yield this._emitQuitters();
-      const session = yield pluvWs.getSession();
+      if (message.type === "$pong") {
+        const elapsedMs = Date.now() - this._lastGarbageCollectMs;
+        if (elapsedMs > GARBAGE_COLLECT_INTERVAL_MS) {
+          yield this.garbageCollect();
+        }
+      }
+      const session = pluvWs.session;
       const user = (_b = session.user) != null ? _b : null;
       this._sendMessage(pluvWs, __spreadValues({
         connectionId: senderId,
@@ -931,9 +1021,19 @@ var IORoom = class {
       const context = {
         context: this._context,
         doc,
+        garbageCollect: () => __async(this, null, function* () {
+          yield this.garbageCollect();
+        }),
+        get presence() {
+          return null;
+        },
+        set presence(presence) {
+          return;
+        },
         room: this.id,
         session: null,
-        sessions: yield this._getSessions()
+        sessions: this._getSessions(),
+        time: (/* @__PURE__ */ new Date()).getTime()
       };
       const resolver = (_a = this._getProcedure(message)) == null ? void 0 : _a.config.sync;
       if (!resolver) return;
@@ -963,7 +1063,7 @@ var IORoom = class {
 };
 
 // src/version.generated.ts
-var version = "0.40.2";
+var version = "0.41.1";
 
 // src/PluvServer.ts
 var PluvServer = class {
@@ -979,11 +1079,12 @@ var PluvServer = class {
           if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
           return true;
         }).reduce(
-          (acc, { id, presence, user }) => __spreadProps(__spreadValues({}, acc), {
+          (acc, { id, presence, timers, user }) => __spreadProps(__spreadValues({}, acc), {
             [id]: {
               connectionId: id,
               presence,
               room,
+              timers: { presence: timers.presence },
               user
             }
           }),
@@ -993,13 +1094,15 @@ var PluvServer = class {
       }),
       $initializeSession: this._procedure.broadcast((data, { session }) => {
         const presence = data == null ? void 0 : data.presence;
+        const timers = session.timers;
         if (!session) return {};
         session.presence = presence;
         return {
           $userJoined: {
             connectionId: session.id,
             user: session.user,
-            presence
+            presence,
+            timers: { presence: timers.presence }
           }
         };
       }).self((_0, _1) => __async(this, [_0, _1], function* (data, { context, doc, room, session }) {
@@ -1035,12 +1138,24 @@ var PluvServer = class {
         }));
         return { $pong: {} };
       }),
-      $updatePresence: this._procedure.broadcast((data, { session }) => {
+      $updatePresence: this._procedure.broadcast((data, context) => {
         const presence = data == null ? void 0 : data.presence;
+        const { session } = context;
         if (!session) return {};
         const updated = Object.assign(/* @__PURE__ */ Object.create(null), session.presence, presence);
-        session.webSocket.presence = updated;
-        return { $presenceUpdated: { presence: updated } };
+        const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
+        if (bytes > MAX_PRESENCE_SIZE_BYTES) {
+          throw new Error(
+            `Large presence. Presence must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
+          );
+        }
+        context.presence = updated;
+        return {
+          $presenceUpdated: {
+            presence: updated,
+            timers: { presence: session.timers.presence }
+          }
+        };
       }),
       $updateStorage: this._procedure.broadcast((data, { context, doc, room }) => {
         var _a;
@@ -1153,8 +1268,16 @@ var PluvServer = class {
       if (!this._authorize) {
         throw new Error("IO does not specify authorize during initialization.");
       }
-      if (this._platform._createToken) return yield this._platform._createToken(params);
       const ioAuthorize = this._getIOAuthorize(params);
+      const user = params.user;
+      const parsed = !!ioAuthorize ? ioAuthorize.user.parse(user) : user;
+      const bytes = new TextEncoder().encode(JSON.stringify(parsed)).length;
+      if (bytes > MAX_USER_SIZE_BYTES) {
+        throw new Error(
+          `createToken called with large payload. User must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`
+        );
+      }
+      if (this._platform._createToken) return yield this._platform._createToken(params);
       const secret = (_a = ioAuthorize == null ? void 0 : ioAuthorize.secret) != null ? _a : null;
       if (!secret) throw new Error("`authorize` was specified without a valid secret");
       return yield authorize({ platform: this._platform, secret }).encode(params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/io",
-  "version": "0.40.2",
+  "version": "0.41.1",
   "description": "@pluv/io server-side websocket manager",
   "author": "leedavidcs",
   "license": "MIT",
@@ -21,21 +21,21 @@
     "jose": "^5.10.0",
     "kleur": "^4.1.5",
     "wonka": "^6.3.5",
-    "@pluv/crdt": "^0.40.2",
-    "@pluv/types": "^0.40.2"
+    "@pluv/crdt": "^0.41.1",
+    "@pluv/types": "^0.41.1"
   },
   "devDependencies": {
-    "eslint": "^9.24.0",
+    "eslint": "^9.25.0",
     "genversion": "^3.2.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@pluv/tsconfig": "^0.40.2",
-    "eslint-config-pluv": "^0.40.2"
+    "@pluv/tsconfig": "^0.41.1",
+    "eslint-config-pluv": "^0.41.1"
   },
   "scripts": {
     "build": "pnpm run version && tsup src/index.ts --format esm,cjs --dts",
     "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
-    "lint": "eslint src/**/*.ts* --fix --max-warnings 0",
+    "lint": "eslint \"src/**/*.ts*\" --fix --max-warnings 0",
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
     "version": "genversion ./src/version.generated.ts --esm"
   }

package/src/AbstractPlatform.ts

@@ -29,7 +29,7 @@ export interface ConvertWebSocketConfig {
 }
 
 export abstract class AbstractPlatform<
-    TWebSocket extends AbstractWebSocket = AbstractWebSocket,
+    TWebSocket extends AbstractWebSocket<any, any> = AbstractWebSocket<any, any>,
     TInitContext extends Record<string, any> = {},
     TRoomContext extends Record<string, any> = {},
     TConfig extends PlatformConfig = PlatformConfig,
@@ -62,9 +62,9 @@ export abstract class AbstractPlatform<
     public abstract convertWebSocket(
         webSocket: InferWebSocketSource<TWebSocket>,
         config: ConvertWebSocketConfig,
-    ): AbstractWebSocket;
+    ): AbstractWebSocket<any, any>;
 
-    public abstract getLastPing(webSocket: AbstractWebSocket): number | null;
+    public abstract getLastPing(webSocket: AbstractWebSocket<any, any>): number | null;
 
     public abstract getSerializedState(webSocket: InferWebSocketSource<TWebSocket>): WebSocketSerializedState | null;
 

package/src/AbstractWebSocket.ts

@@ -54,7 +54,7 @@ export interface AbstractWebSocketConfig {
     room: string;
 }
 
-export abstract class AbstractWebSocket<TWebSocket = any> {
+export abstract class AbstractWebSocket<TWebSocket = any, TAuthorize extends IOAuthorize<any, any> | null = null> {
     /** The connection is not yet open. */
     public readonly CONNECTING = 0;
     /** The connection is open and ready to communicate. */
@@ -68,15 +68,15 @@ export abstract class AbstractWebSocket<TWebSocket = any> {
     public readonly room: string;
     public readonly webSocket: TWebSocket;
 
-    private _user: BaseUser | null = null;
-
     protected readonly _platform: AbstractPlatform<this>;
 
     public abstract set presence(presence: JsonObject | null);
     public abstract get readyState(): 0 | 1 | 2 | 3;
+    public abstract get session(): WebSocketSession<TAuthorize>;
     public abstract get sessionId(): string;
     public abstract get state(): WebSocketSerializedState;
     public abstract set state(state: WebSocketSerializedState);
+    public abstract set user(user: InferIOAuthorizeUser<TAuthorize>);
 
     constructor(webSocket: TWebSocket, config: AbstractWebSocketConfig) {
         const { persistence, platform, room } = config;
@@ -104,23 +104,6 @@ export abstract class AbstractWebSocket<TWebSocket = any> {
 
     public abstract terminate(): void;
 
-    public async getSession<TAuthorize extends IOAuthorize<any, any> | null>(): Promise<WebSocketSession<TAuthorize>> {
-        const sessionId = this.sessionId;
-        const state = this.state;
-        const room = state.room;
-
-        const user = this._user ?? (await this.persistence.getUser(room, sessionId));
-
-        this._user = user as BaseUser;
-
-        return {
-            ...state,
-            id: sessionId,
-            user: user as InferIOAuthorizeUser<TAuthorize>,
-            webSocket: this,
-        };
-    }
-
     public handleError(params: AbstractWebSocketHandleErrorParams): void {
         const { error, message: _message, room, session } = params;