@spacelr/sdk 0.10.1 → 0.10.3

package/dist/index.mjs

@@ -840,13 +840,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 = {
@@ -861,13 +863,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;
       }
@@ -877,7 +879,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;
     }
   }
@@ -936,6 +938,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) {
@@ -1074,10 +1122,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", () => {
@@ -1282,38 +1330,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();
   }
@@ -1339,15 +1395,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));
@@ -1379,8 +1439,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) {
@@ -1388,7 +1448,7 @@ var RealtimeClient = class {
       }
       set.delete(sibling);
     }
-    this.streamSubscriptions.delete(streamKey);
+    this.streamSubscriptions.delete(subscriptionKey);
   }
 };
 
@@ -1827,9 +1887,11 @@ var AuthModule = class {
   }
   async storeTokensFromRegister(response) {
     if (!response.access_token) return;
+    const expiresAt = response.expires_in ? Math.floor(Date.now() / 1e3) + response.expires_in : void 0;
     await this.tokenManager.setTokens({
       accessToken: response.access_token,
-      refreshToken: response.refresh_token
+      refreshToken: response.refresh_token,
+      expiresAt
     });
     this.emitState("authenticated");
   }