@spacelr/sdk 0.10.2 → 0.10.3

package/dist/index.d.mts

@@ -693,6 +693,32 @@ declare class RealtimeClient {
     onConnectionStateChanged(listener: (state: ConnectionState) => void): () => void;
     private setConnectionState;
     private buildRoomKey;
+    /**
+     * Stream subscription identity (#643): `streamKey` + canonical(`where`), so
+     * two `subscribeEvents` on the same collection with different filters get
+     * distinct handshakes/readers instead of one colliding on the bare streamKey.
+     * Empty/absent `where` keeps the bare streamKey. Same type-preserving sorted
+     * encoding as `buildRoomKey` / the gateway's `streamSubscriptionKey`; it is a
+     * client-local Map key only (never sent — the gateway derives its own).
+     */
+    private streamSubscriptionKey;
+    /**
+     * All per-filter subscription sets registered for one collection's stream
+     * (#643). The socket delivers events keyed only by `streamKey` (no `where`),
+     * so a dispatch / gap for `streamKey` must reach every filter variant:
+     * the bare `streamKey` entry plus any `${streamKey}?…` filtered entries.
+     */
+    private streamSetsForStreamKey;
+    /**
+     * Whether a stream event should reach a subscriber with this `where`. The
+     * server already filters doc-bearing events per per-filter reader, but events
+     * arrive on one socket without a `where`, so we re-filter to route each to the
+     * right subscriber (and as defense against desync/over-delivery). An event
+     * with no document (tombstone delete) can't be filtered — it is delivered to
+     * every subscriber on the collection, as the server forwards it to every
+     * reader. Empty `where` matches everything.
+     */
+    private eventMatchesStreamWhere;
     private ensureConnected;
     private connect;
     private eventMatchesRoom;

package/dist/index.d.ts

@@ -693,6 +693,32 @@ declare class RealtimeClient {
     onConnectionStateChanged(listener: (state: ConnectionState) => void): () => void;
     private setConnectionState;
     private buildRoomKey;
+    /**
+     * Stream subscription identity (#643): `streamKey` + canonical(`where`), so
+     * two `subscribeEvents` on the same collection with different filters get
+     * distinct handshakes/readers instead of one colliding on the bare streamKey.
+     * Empty/absent `where` keeps the bare streamKey. Same type-preserving sorted
+     * encoding as `buildRoomKey` / the gateway's `streamSubscriptionKey`; it is a
+     * client-local Map key only (never sent — the gateway derives its own).
+     */
+    private streamSubscriptionKey;
+    /**
+     * All per-filter subscription sets registered for one collection's stream
+     * (#643). The socket delivers events keyed only by `streamKey` (no `where`),
+     * so a dispatch / gap for `streamKey` must reach every filter variant:
+     * the bare `streamKey` entry plus any `${streamKey}?…` filtered entries.
+     */
+    private streamSetsForStreamKey;
+    /**
+     * Whether a stream event should reach a subscriber with this `where`. The
+     * server already filters doc-bearing events per per-filter reader, but events
+     * arrive on one socket without a `where`, so we re-filter to route each to the
+     * right subscriber (and as defense against desync/over-delivery). An event
+     * with no document (tombstone delete) can't be filtered — it is delivered to
+     * every subscriber on the collection, as the server forwards it to every
+     * reader. Empty `where` matches everything.
+     */
+    private eventMatchesStreamWhere;
     private ensureConnected;
     private connect;
     private eventMatchesRoom;

package/dist/index.js

@@ -883,13 +883,15 @@ var RealtimeClient = class {
     }
     await this.ensureConnected();
     const streamKey = `stream:${options.projectId}:${options.collectionName}`;
+    const subscriptionKey = this.streamSubscriptionKey(streamKey, options.where);
     const state = {
       options,
       lastDeliveredId: options.sinceId ?? null,
       streamKey,
+      subscriptionKey,
       dispatchQueue: Promise.resolve()
     };
-    const existing = this.streamSubscriptions.get(streamKey);
+    const existing = this.streamSubscriptions.get(subscriptionKey);
     if (existing && existing.size > 0) {
       existing.add(state);
       const syntheticAck = {
@@ -904,13 +906,13 @@ var RealtimeClient = class {
     }
     const set = /* @__PURE__ */ new Set();
     set.add(state);
-    this.streamSubscriptions.set(streamKey, set);
+    this.streamSubscriptions.set(subscriptionKey, set);
     try {
       const ack = await this.emitSubscribeEvents(state);
       if (ack.error) {
         const message = ack.message ?? ack.error;
         const err = new SpacelrError(message, ack.error);
-        this.evictStreamKey(streamKey, err, state);
+        this.evictStreamKey(subscriptionKey, err, state);
         options.onError?.(err);
         throw err;
       }
@@ -920,7 +922,7 @@ var RealtimeClient = class {
       };
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
-      this.evictStreamKey(streamKey, error, state);
+      this.evictStreamKey(subscriptionKey, error, state);
       throw error;
     }
   }
@@ -979,6 +981,52 @@ var RealtimeClient = class {
     const filterStr = Object.keys(where).sort().map((k) => `${k}=${JSON.stringify(where[k])}`).join("&");
     return `${base}?${filterStr}`;
   }
+  /**
+   * Stream subscription identity (#643): `streamKey` + canonical(`where`), so
+   * two `subscribeEvents` on the same collection with different filters get
+   * distinct handshakes/readers instead of one colliding on the bare streamKey.
+   * Empty/absent `where` keeps the bare streamKey. Same type-preserving sorted
+   * encoding as `buildRoomKey` / the gateway's `streamSubscriptionKey`; it is a
+   * client-local Map key only (never sent — the gateway derives its own).
+   */
+  streamSubscriptionKey(streamKey, where) {
+    if (!where || Object.keys(where).length === 0) return streamKey;
+    const filterStr = Object.keys(where).sort().map((k) => `${k}=${JSON.stringify(where[k])}`).join("&");
+    return `${streamKey}?${filterStr}`;
+  }
+  /**
+   * All per-filter subscription sets registered for one collection's stream
+   * (#643). The socket delivers events keyed only by `streamKey` (no `where`),
+   * so a dispatch / gap for `streamKey` must reach every filter variant:
+   * the bare `streamKey` entry plus any `${streamKey}?…` filtered entries.
+   */
+  streamSetsForStreamKey(streamKey) {
+    const sets = [];
+    const prefix = `${streamKey}?`;
+    for (const [key, set] of this.streamSubscriptions) {
+      if (key === streamKey || key.startsWith(prefix)) sets.push(set);
+    }
+    return sets;
+  }
+  /**
+   * Whether a stream event should reach a subscriber with this `where`. The
+   * server already filters doc-bearing events per per-filter reader, but events
+   * arrive on one socket without a `where`, so we re-filter to route each to the
+   * right subscriber (and as defense against desync/over-delivery). An event
+   * with no document (tombstone delete) can't be filtered — it is delivered to
+   * every subscriber on the collection, as the server forwards it to every
+   * reader. Empty `where` matches everything.
+   */
+  eventMatchesStreamWhere(event, where) {
+    if (!where || Object.keys(where).length === 0) return true;
+    if (!event.document) return true;
+    for (const [key, value] of Object.entries(where)) {
+      if (!whereValueMatches(resolveWherePath(event.document, key), value)) {
+        return false;
+      }
+    }
+    return true;
+  }
   async ensureConnected() {
     if (this.socket?.connected) return;
     if (this.connecting) {
@@ -1117,10 +1165,10 @@ var RealtimeClient = class {
       });
       this.socket.on("event-gap", (info) => {
         const streamKey = `stream:${info.projectId}:${info.collectionName}`;
-        const set = this.streamSubscriptions.get(streamKey);
-        if (!set) return;
-        for (const state of set) {
-          state.options.onGap?.(info);
+        for (const set of this.streamSetsForStreamKey(streamKey)) {
+          for (const state of set) {
+            state.options.onGap?.(info);
+          }
         }
       });
       this.socket.on("disconnect", () => {
@@ -1325,38 +1373,46 @@ var RealtimeClient = class {
     return payload;
   }
   unsubscribeStream(state) {
-    const set = this.streamSubscriptions.get(state.streamKey);
+    const set = this.streamSubscriptions.get(state.subscriptionKey);
     if (!set) return;
     set.delete(state);
     if (set.size === 0) {
-      this.streamSubscriptions.delete(state.streamKey);
-      this.socket?.emit("unsubscribe-events", {
+      this.streamSubscriptions.delete(state.subscriptionKey);
+      const payload = {
         projectId: state.options.projectId,
         collectionName: state.options.collectionName
-      });
+      };
+      if (state.options.where && Object.keys(state.options.where).length > 0) {
+        payload["where"] = state.options.where;
+      }
+      this.socket?.emit("unsubscribe-events", payload);
     }
   }
   dispatchStreamEvent(payload) {
     if (!payload.eventId) return Promise.resolve();
     const streamKey = `stream:${payload.projectId}:${payload.collectionName}`;
-    const set = this.streamSubscriptions.get(streamKey);
-    if (!set) return Promise.resolve();
+    const sets = this.streamSetsForStreamKey(streamKey);
+    if (sets.length === 0) return Promise.resolve();
     const entryId = payload.eventId;
-    for (const state of set) {
-      state.dispatchQueue = state.dispatchQueue.then(async () => {
-        const liveSet = this.streamSubscriptions.get(state.streamKey);
-        if (!liveSet?.has(state)) return;
-        try {
-          await state.options.onEvent({ eventId: entryId, event: payload });
-          state.lastDeliveredId = entryId;
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
+    for (const set of sets) {
+      for (const state of set) {
+        if (!this.eventMatchesStreamWhere(payload, state.options.where)) continue;
+        state.dispatchQueue = state.dispatchQueue.then(async () => {
+          const liveSet = this.streamSubscriptions.get(state.subscriptionKey);
+          if (!liveSet?.has(state)) return;
+          if (state.lastDeliveredId === entryId) return;
           try {
-            state.options.onError?.(error);
-          } catch {
+            await state.options.onEvent({ eventId: entryId, event: payload });
+            state.lastDeliveredId = entryId;
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            try {
+              state.options.onError?.(error);
+            } catch {
+            }
           }
-        }
-      });
+        });
+      }
     }
     return Promise.resolve();
   }
@@ -1382,15 +1438,19 @@ var RealtimeClient = class {
           state.options.onError?.(err);
         }
         if (PERMANENT_STREAM_ACK_ERRORS.has(ack.error)) {
-          this.streamSubscriptions.delete(primary.streamKey);
+          this.streamSubscriptions.delete(primary.subscriptionKey);
         }
         return;
       }
-      if (!this.streamSubscriptions.has(primary.streamKey)) {
-        this.socket?.emit("unsubscribe-events", {
+      if (!this.streamSubscriptions.has(primary.subscriptionKey)) {
+        const payload = {
           projectId: primary.options.projectId,
           collectionName: primary.options.collectionName
-        });
+        };
+        if (primary.options.where && Object.keys(primary.options.where).length > 0) {
+          payload["where"] = primary.options.where;
+        }
+        this.socket?.emit("unsubscribe-events", payload);
       }
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
@@ -1422,8 +1482,8 @@ var RealtimeClient = class {
    * streamKey via the dedup path. Fires `onError` on all siblings, then
    * removes the entire streamKey entry from `streamSubscriptions`.
    */
-  evictStreamKey(streamKey, err, primary) {
-    const set = this.streamSubscriptions.get(streamKey);
+  evictStreamKey(subscriptionKey, err, primary) {
+    const set = this.streamSubscriptions.get(subscriptionKey);
     if (!set) return;
     for (const sibling of [...set]) {
       if (sibling !== primary) {
@@ -1431,7 +1491,7 @@ var RealtimeClient = class {
       }
       set.delete(sibling);
     }
-    this.streamSubscriptions.delete(streamKey);
+    this.streamSubscriptions.delete(subscriptionKey);
   }
 };