@pylonsync/sync 0.22.40 → 0.22.41

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { LocalStore } from "./local-store";
 import { MutationQueue } from "./mutation-queue";
 import { type RoomError, type RoomMember, type RoomSubscriber } from "./room-subscriptions";
 import { SessionResolver } from "./session-resolver";
-export { RoomSubscriptions, type RoomError, type RoomErrorCode, type RoomMember, type RoomMessage, type RoomMessageSubscriber, type RoomSubscriber, } from "./room-subscriptions";
+export { RoomSubscriptions, rowRoom, type RoomError, type RoomErrorCode, type RoomMember, type RoomMessage, type RoomMessageSubscriber, type RoomSubscriber, } from "./room-subscriptions";
 export { IndexedDBPersistence, persistChange } from "./persistence";
 export type { ReplicaPersistence } from "./persistence";
 export { BEARER_REJECTED_HEADER, bearerRejected, buildRequest, clearRejectedToken, pylonFetch, pylonFetchRaw, PylonHttpError, resolveBaseUrl, } from "./transport";

package/dist/room-subscriptions.d.ts

@@ -4,7 +4,18 @@ export interface RoomMember {
     data?: Record<string, unknown>;
 }
 /** Reason codes the SDK exposes on a room subscription error. */
-export type RoomErrorCode = "NOT_IN_ROOM" | "UNKNOWN";
+/**
+ * - `NOT_IN_ROOM`: subscribed before joining (rejoin and resubscribe).
+ * - `ROOM_FORBIDDEN`: a room tied to a row the caller may not read.
+ * - `ROOM_REVOKED`: the caller lost access to that row while in the room.
+ */
+export type RoomErrorCode = "NOT_IN_ROOM" | "ROOM_FORBIDDEN" | "ROOM_REVOKED" | "UNKNOWN";
+/**
+ * The room tied to a row: its members are the people who may read the row,
+ * and the server checks that on every room operation. `@` starts only these
+ * names.
+ */
+export declare function rowRoom(entity: string, id: string): string;
 export interface RoomError {
     code: RoomErrorCode;
     message?: string;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.22.40",
+  "version": "0.22.41",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",

package/src/index.ts

@@ -22,6 +22,7 @@ import { OpQueue } from "./op-queue";
 import {
   RoomSubscriptions,
   type RoomError,
+  type RoomErrorCode,
   type RoomMember,
   type RoomSubscriber,
 } from "./room-subscriptions";
@@ -37,6 +38,7 @@ import {
 import { generateClientId, generateId } from "./ids";
 export {
   RoomSubscriptions,
+  rowRoom,
   type RoomError,
   type RoomErrorCode,
   type RoomMember,
@@ -4152,6 +4154,20 @@ export class SyncEngine {
       }
       return;
     }
+    // The server removed us from a room tied to a row we may no longer
+    // read. It stops sending the room's events; clear the members and tell
+    // the hook, which stops rejoining.
+    if (msg.type === "room-revoked" && typeof msg.room === "string") {
+      const room = msg.room;
+      const error: RoomError = { code: "ROOM_REVOKED" };
+      this.rooms.applySnapshot(room, []);
+      this.rooms.applyError(room, error);
+      if ((this.roomForwarders.get(room)?.size ?? 0) > 0) {
+        this.broadcastToTabs({ type: "room-fanout-snapshot", room, members: [] });
+        this.broadcastToTabs({ type: "room-fanout-error", room, error });
+      }
+      return;
+    }
     if (
       msg.type === "error" &&
       typeof msg.room === "string" &&
@@ -4163,7 +4179,8 @@ export class SyncEngine {
       // path right now, but the dispatch is keyed by `code` so future
       // error codes (rate-limited, room-full, etc.) route here too.
       const room = msg.room;
-      const code = msg.code === "NOT_IN_ROOM" ? "NOT_IN_ROOM" : "UNKNOWN";
+      const code: RoomErrorCode =
+        msg.code === "NOT_IN_ROOM" || msg.code === "ROOM_FORBIDDEN" ? msg.code : "UNKNOWN";
       const error: RoomError = {
         code,
         message: typeof msg.message === "string" ? msg.message : undefined,

package/src/room-subscriptions.test.ts

@@ -299,3 +299,15 @@ describe("RoomSubscriptions: resubscribe after a rejoin", () => {
     expect(sent).toEqual([{ type: "room-sub-resubscribe", room: "channel:a" }]);
   });
 });
+
+test("presence from someone not in the list adds them back", () => {
+  const { rooms } = makeHarness();
+  rooms.register("doc", () => {});
+  rooms.applySnapshot("doc", [{ user_id: "alice", joined_at: "t", data: {} }]);
+  // A leave relayed from another machine, though Alice is still connected
+  // through this one.
+  rooms.applyUpdate("doc", "leave", { user_id: "alice", joined_at: "", data: {} }, undefined);
+  expect(rooms.members("doc")).toEqual([]);
+  rooms.applyUpdate("doc", "presence", { user_id: "alice", joined_at: "", data: {} }, { cursor: 4 });
+  expect(rooms.members("doc")).toEqual([{ user_id: "alice", joined_at: "", data: { cursor: 4 } }]);
+});

package/src/room-subscriptions.ts

@@ -51,7 +51,21 @@ export interface RoomMember {
 }
 
 /** Reason codes the SDK exposes on a room subscription error. */
-export type RoomErrorCode = "NOT_IN_ROOM" | "UNKNOWN";
+/**
+ * - `NOT_IN_ROOM`: subscribed before joining (rejoin and resubscribe).
+ * - `ROOM_FORBIDDEN`: a room tied to a row the caller may not read.
+ * - `ROOM_REVOKED`: the caller lost access to that row while in the room.
+ */
+export type RoomErrorCode = "NOT_IN_ROOM" | "ROOM_FORBIDDEN" | "ROOM_REVOKED" | "UNKNOWN";
+
+/**
+ * The room tied to a row: its members are the people who may read the row,
+ * and the server checks that on every room operation. `@` starts only these
+ * names.
+ */
+export function rowRoom(entity: string, id: string): string {
+  return `@${entity}/${id}`;
+}
 
 export interface RoomError {
   code: RoomErrorCode;
@@ -272,11 +286,22 @@ export class RoomSubscriptions {
           _data && typeof _data === "object"
             ? (_data as Record<string, unknown>)
             : undefined;
-        entry.members = entry.members.map((m) =>
-          m.user_id === member.user_id
-            ? { ...m, ...member, ...(presence ? { data: presence } : {}) }
-            : m,
-        );
+        if (entry.members.some((m) => m.user_id === member.user_id)) {
+          entry.members = entry.members.map((m) =>
+            m.user_id === member.user_id
+              ? { ...m, ...member, ...(presence ? { data: presence } : {}) }
+              : m,
+          );
+        } else {
+          // Presence from someone not in the list is in the room: on a
+          // cluster, a leave relayed from one machine can drop a person
+          // still connected through another. Their next presence puts them
+          // back.
+          entry.members = [
+            ...entry.members,
+            { ...member, joined_at: member.joined_at ?? "", ...(presence ? { data: presence } : {}) },
+          ];
+        }
         break;
       }
       case "broadcast": {