@emeryld/rrroutes-client 2.8.8 → 2.8.10

package/dist/index.mjs

@@ -1924,7 +1924,9 @@ var SocketClient = class {
     this.hbTimer = null;
     // stats
     this.roomCounts = /* @__PURE__ */ new Map();
+    this.roomJoinMeta = /* @__PURE__ */ new Map();
     this.handlerMap = /* @__PURE__ */ new Map();
+    this.hasConnected = false;
     this.events = events;
     this.socket = opts.socket ?? null;
     this.environment = opts.environment ?? "development";
@@ -1933,11 +1935,14 @@ var SocketClient = class {
     this.sysEvents = opts.sys;
     this.roomJoinSchema = buildRoomPayloadSchema(this.config.joinMetaMessage);
     this.roomLeaveSchema = buildRoomPayloadSchema(this.config.leaveMetaMessage);
+    this.reconnection = this.resolveReconnectionOptions(opts.reconnection);
+    this.hasConnected = Boolean(this.socket?.connected);
     const hb = opts.heartbeat ?? {};
     this.hb = {
       intervalMs: hb.intervalMs ?? 15e3,
       timeoutMs: hb.timeoutMs ?? 7500
     };
+    this.configureReconnection();
     if (!this.socket) {
       this.dbg({
         type: "lifecycle",
@@ -1964,6 +1969,8 @@ var SocketClient = class {
         return;
       }
       const socket = this.socket;
+      const isReconnect = this.hasConnected;
+      this.hasConnected = true;
       this.dbg({
         type: "connection",
         phase: "connect_event",
@@ -1973,12 +1980,15 @@ var SocketClient = class {
         }
       });
       this.logSocketConfigSnapshot("connect_event");
-      void Promise.resolve(
-        this.getSysEvent("sys:connect")({
+      void (async () => {
+        if (isReconnect && this.reconnection.restoreRooms) {
+          await this.restoreRooms();
+        }
+        await this.getSysEvent("sys:connect")({
           socket,
           client: this
-        })
-      ).catch((error) => {
+        });
+      })().catch((error) => {
         this.dbg({
           type: "connection",
           phase: "connect_event",
@@ -2150,7 +2160,7 @@ var SocketClient = class {
     };
     if (this.socket) {
       this.socket.on("connect", this.onConnect);
-      this.socket.on("reconnect", this.onReconnect);
+      this.socket.io.on("reconnect", this.onReconnect);
       this.socket.on("disconnect", this.onDisconnect);
       this.socket.on("connect_error", this.onConnectError);
       this.socket.on("sys:pong", this.onPong);
@@ -2223,6 +2233,57 @@ var SocketClient = class {
   getSysEvent(name) {
     return this.sysEvents[name];
   }
+  resolveReconnectionOptions(value) {
+    if (value === true) {
+      return { mode: "managed", restoreRooms: true };
+    }
+    if (value === false) {
+      return { mode: "manual", restoreRooms: true };
+    }
+    return {
+      ...value,
+      mode: value?.mode ?? "inherit",
+      restoreRooms: value?.restoreRooms ?? true
+    };
+  }
+  configureReconnection() {
+    if (!this.socket) return;
+    const manager = this.socket.io;
+    const options = this.reconnection;
+    if (options.mode === "managed") {
+      manager.reconnection(true);
+      if (options.attempts !== void 0) {
+        manager.reconnectionAttempts(options.attempts);
+      }
+      if (options.delayMs !== void 0) {
+        manager.reconnectionDelay(options.delayMs);
+      }
+      if (options.delayMaxMs !== void 0) {
+        manager.reconnectionDelayMax(options.delayMaxMs);
+      }
+      if (options.randomizationFactor !== void 0) {
+        manager.randomizationFactor(options.randomizationFactor);
+      }
+      if (options.timeoutMs !== void 0) {
+        manager.timeout(options.timeoutMs);
+      }
+    } else if (options.mode === "manual") {
+      manager.reconnection(false);
+    }
+    this.dbg({
+      type: "connection",
+      phase: "reconnect_config",
+      details: {
+        mode: options.mode,
+        restoreRooms: options.restoreRooms,
+        attempts: options.attempts,
+        delayMs: options.delayMs,
+        delayMaxMs: options.delayMaxMs,
+        randomizationFactor: options.randomizationFactor,
+        timeoutMs: options.timeoutMs
+      }
+    });
+  }
   dbg(e) {
     const d = this.debug;
     if (!d.logger) return;
@@ -2254,6 +2315,63 @@ var SocketClient = class {
       handlers
     };
   }
+  /**
+   * Re-emit joins for all rooms with active references without incrementing
+   * their reference counts. This is safe to call after any externally or
+   * internally managed reconnect.
+   */
+  async restoreRooms() {
+    if (!this.socket?.connected) {
+      this.dbg({
+        type: "room",
+        phase: "restore",
+        rooms: [],
+        err: "Socket is not connected"
+      });
+      return [];
+    }
+    const restored = [];
+    const desiredRooms = Array.from(this.roomCounts.entries()).filter(([, count]) => count > 0).map(([room]) => room);
+    for (const room of desiredRooms) {
+      const meta = this.roomJoinMeta.get(room);
+      const allowed = await this.getSysEvent("sys:room_join")({
+        rooms: [room],
+        meta,
+        socket: this.socket,
+        client: this
+      });
+      if (!allowed) {
+        this.dbg({
+          type: "room",
+          phase: "restore",
+          rooms: [room],
+          err: "sys:room_join handler aborted restore"
+        });
+        continue;
+      }
+      const payloadResult = this.roomJoinSchema.safeParse({
+        rooms: [room],
+        meta
+      });
+      if (!payloadResult.success) {
+        this.dbg({
+          type: "room",
+          phase: "restore",
+          rooms: [room],
+          err: "payload validation failed",
+          details: this.getValidationDetails(payloadResult.error)
+        });
+        continue;
+      }
+      this.socket.emit(
+        "sys:room_join",
+        payloadResult.data
+      );
+      restored.push(room);
+    }
+    this.dbg({ type: "room", phase: "restore", rooms: restored });
+    return restored;
+  }
   toArray(rooms) {
     return rooms == null ? [] : Array.isArray(rooms) ? rooms : [rooms];
   }
@@ -2441,6 +2559,9 @@ var SocketClient = class {
       }
       const payload = payloadResult.data;
       const normalizedRooms = this.toArray(payload.rooms);
+      for (const room of normalizedRooms) {
+        this.roomJoinMeta.set(room, meta);
+      }
       this.socket.emit("sys:room_join", payload);
       this.dbg({ type: "room", phase: "join", rooms: normalizedRooms });
     }
@@ -2499,6 +2620,9 @@ var SocketClient = class {
       }
       const payload = payloadResult.data;
       const normalizedRooms = this.toArray(payload.rooms);
+      for (const room of normalizedRooms) {
+        this.roomJoinMeta.delete(room);
+      }
       this.socket.emit("sys:room_leave", payload);
       this.dbg({ type: "room", phase: "leave", rooms: normalizedRooms });
     }
@@ -2641,7 +2765,7 @@ var SocketClient = class {
     this.stopHeartbeat("destroy");
     if (socket) {
       socket.off("connect", this.onConnect);
-      socket.off("reconnect", this.onReconnect);
+      socket.io.off("reconnect", this.onReconnect);
       socket.off("disconnect", this.onDisconnect);
       socket.off("connect_error", this.onConnectError);
       socket.off("sys:pong", this.onPong);
@@ -2658,6 +2782,7 @@ var SocketClient = class {
       await this.leaveRooms(toLeave, leaveMeta);
     }
     this.roomCounts.clear();
+    this.roomJoinMeta.clear();
     this.dbg({
       type: "lifecycle",
       phase: "destroy_complete",
@@ -3178,15 +3303,6 @@ function buildSocketedRoute(options) {
         return;
       }
       const { joinMeta, leaveMeta } = roomState;
-      if (!joinMeta || !leaveMeta) {
-        dbg2(debug, {
-          type: "room",
-          phase: "join_skip",
-          rooms: roomState.rooms,
-          reason: "missing_meta"
-        });
-        return;
-      }
       let active = true;
       dbg2(debug, {
         type: "room",