@spacelr/sdk 0.9.2 → 0.10.1

package/dist/index.mjs

@@ -614,6 +614,57 @@ var PERMANENT_STREAM_ACK_ERRORS = /* @__PURE__ */ new Set([
   "Not a member of this project",
   "Subscribe denied"
 ]);
+function isWhereScalar(value) {
+  const t = typeof value;
+  return t === "string" || t === "number" || t === "boolean";
+}
+function isWhereOperator(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) return false;
+  const op = keys[0];
+  if (op !== "in" && op !== "array-contains-any") return false;
+  const candidates = value[op];
+  return Array.isArray(candidates) && candidates.every(isWhereScalar);
+}
+var WHERE_PATH_ABSENT = /* @__PURE__ */ Symbol("where-path-absent");
+var WHERE_PATH_UNRESOLVABLE = /* @__PURE__ */ Symbol("where-path-unresolvable");
+var RESERVED_PATH_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var MAX_WHERE_PATH_SEGMENTS = 16;
+function resolveWherePath(document2, key) {
+  const segments = key.split(".");
+  if (segments.length > MAX_WHERE_PATH_SEGMENTS) return WHERE_PATH_ABSENT;
+  let cur = document2;
+  for (const segment of segments) {
+    if (RESERVED_PATH_SEGMENTS.has(segment)) return WHERE_PATH_ABSENT;
+    if (cur === null || cur === void 0) return WHERE_PATH_ABSENT;
+    if (Array.isArray(cur)) return WHERE_PATH_UNRESOLVABLE;
+    if (typeof cur !== "object") return WHERE_PATH_ABSENT;
+    if (!Object.prototype.hasOwnProperty.call(cur, segment)) {
+      return WHERE_PATH_ABSENT;
+    }
+    cur = cur[segment];
+  }
+  return cur === void 0 ? WHERE_PATH_ABSENT : cur;
+}
+function whereValueMatches(actual, expected) {
+  if (actual === WHERE_PATH_ABSENT || actual === WHERE_PATH_UNRESOLVABLE) {
+    return false;
+  }
+  if (isWhereOperator(expected)) {
+    if ("in" in expected) {
+      if (Array.isArray(actual)) return false;
+      return expected.in.includes(actual);
+    }
+    if (!Array.isArray(actual)) return false;
+    const candidates = expected["array-contains-any"];
+    return actual.some((el) => candidates.includes(el));
+  }
+  if (Array.isArray(actual)) return actual.includes(expected);
+  return actual === expected;
+}
 var RealtimeClient = class {
   constructor(config) {
     this.socket = null;
@@ -621,6 +672,21 @@ var RealtimeClient = class {
     this.connecting = null;
     // Store original where objects per room for reconnect resubscription
     this.roomWhereMap = /* @__PURE__ */ new Map();
+    // Per-room, per-callback error handlers so EVERY subscriber to a room (not
+    // just the first) is notified on a denial, and a departed subscriber's handler
+    // is never left dangling for its still-active siblings (#661).
+    this.roomErrorMap = /* @__PURE__ */ new Map();
+    // Per-room generation stamp, taken from a global monotonic counter each time a
+    // room becomes active. A re-subscribe snapshots the room's stamp and acts on
+    // the ack only if it is still current — so a late ack cannot notify or clean
+    // up after the app has unsubscribed/re-subscribed (#661). Entries are deleted
+    // on last-unsubscribe (bounded); the global counter guarantees a re-subscribe
+    // always gets a strictly higher stamp, so there is no ABA hole.
+    this.roomGeneration = /* @__PURE__ */ new Map();
+    this.subEpoch = 0;
+    // Rooms with a re-subscribe handshake in flight — dedupes the duplicate
+    // `subscription-invalidated` events the gateway emits per evicted room (#661).
+    this.resubscribingRooms = /* @__PURE__ */ new Set();
     this.unsubscribeFromTokenRefreshed = null;
     // Wake-up listeners (browser only) — recover from long OS suspends where
     // socket.io's internal reconnect loop may have already given up.
@@ -649,7 +715,17 @@ var RealtimeClient = class {
     }
     const callbacks = this.subscriptions.get(room);
     callbacks?.add(callback);
+    if (onError) {
+      let handlers = this.roomErrorMap.get(room);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Map();
+        this.roomErrorMap.set(room, handlers);
+      }
+      handlers.set(callback, onError);
+    }
     if (callbacks?.size === 1) {
+      const generation = ++this.subEpoch;
+      this.roomGeneration.set(room, generation);
       if (where && Object.keys(where).length > 0) {
         this.roomWhereMap.set(room, where);
       }
@@ -661,8 +737,8 @@ var RealtimeClient = class {
         "subscribe",
         payload,
         (response) => {
-          if (response.error && onError) {
-            onError(new Error(response.error));
+          if (response.error && this.roomGeneration.get(room) === generation) {
+            this.notifyRoomError(room, this.toSubscribeError(response));
           }
         }
       );
@@ -671,9 +747,12 @@ var RealtimeClient = class {
       const callbacks2 = this.subscriptions.get(room);
       if (callbacks2) {
         callbacks2.delete(callback);
+        this.roomErrorMap.get(room)?.delete(callback);
         if (callbacks2.size === 0) {
           this.subscriptions.delete(room);
           this.roomWhereMap.delete(room);
+          this.roomErrorMap.delete(room);
+          this.roomGeneration.delete(room);
           const payload = { projectId, collectionName };
           if (where && Object.keys(where).length > 0) {
             payload["where"] = where;
@@ -826,6 +905,9 @@ var RealtimeClient = class {
     }
     this.subscriptions.clear();
     this.roomWhereMap.clear();
+    this.roomErrorMap.clear();
+    this.roomGeneration.clear();
+    this.resubscribingRooms.clear();
     this.streamSubscriptions.clear();
     this.connecting = null;
   }
@@ -975,6 +1057,18 @@ var RealtimeClient = class {
           }
         }
       });
+      this.socket.on(
+        "subscription-invalidated",
+        (payload) => {
+          if (!payload?.projectId || !payload?.collectionName) return;
+          const base = `db:${payload.projectId}:${payload.collectionName}`;
+          for (const room of this.subscriptions.keys()) {
+            if (room === base || room.startsWith(`${base}?`)) {
+              this.resubscribeRoom(room);
+            }
+          }
+        }
+      );
       this.socket.on("event", (payload) => {
         this.dispatchStreamEvent(payload).catch(() => void 0);
       });
@@ -1002,12 +1096,7 @@ var RealtimeClient = class {
     if (!where) return false;
     if (!event.document) return false;
     for (const [key, value] of Object.entries(where)) {
-      const docValue = event.document[key];
-      if (Array.isArray(docValue)) {
-        if (!docValue.includes(value)) {
-          return false;
-        }
-      } else if (docValue !== value) {
+      if (!whereValueMatches(resolveWherePath(event.document, key), value)) {
         return false;
       }
     }
@@ -1081,31 +1170,88 @@ var RealtimeClient = class {
     this.onOnline = null;
   }
   resubscribeAll() {
+    this.resubscribingRooms.clear();
     for (const [room] of this.subscriptions) {
-      const queryIdx = room.indexOf("?");
-      const basePart = queryIdx >= 0 ? room.substring(0, queryIdx) : room;
-      const parts = basePart.split(":");
-      if (parts.length >= 3) {
-        const projectId = parts[1];
-        const collectionName = parts.slice(2).join(":");
-        const payload = { projectId, collectionName };
-        const where = this.roomWhereMap.get(room);
-        if (where) {
-          payload["where"] = where;
-        }
-        this.socket?.emit(
-          "subscribe",
-          payload,
-          (response) => {
-            if (response?.error) {
-              this.subscriptions.delete(room);
-              this.roomWhereMap.delete(room);
-            }
-          }
-        );
+      this.resubscribeRoom(room);
+    }
+  }
+  /**
+   * Parse a pubsub room key back into its projectId + collectionName.
+   * Room format: `db:{projectId}:{collectionName}` or that base plus `?filter`.
+   * Returns null for anything that isn't a well-formed `db:` room.
+   */
+  parseRoom(room) {
+    const queryIdx = room.indexOf("?");
+    const basePart = queryIdx >= 0 ? room.substring(0, queryIdx) : room;
+    const parts = basePart.split(":");
+    if (parts.length < 3 || parts[0] !== "db") return null;
+    return { projectId: parts[1], collectionName: parts.slice(2).join(":") };
+  }
+  /** Build an Error carrying the gateway's typed `errorCode` (if any) as `.code`. */
+  toSubscribeError(response) {
+    const err = new Error(response.error ?? "Subscribe denied");
+    if (response.errorCode) err.code = response.errorCode;
+    return err;
+  }
+  /** Call every subscriber's error handler registered for `room` (#661). */
+  notifyRoomError(room, error) {
+    const handlers = this.roomErrorMap.get(room);
+    if (!handlers) return;
+    for (const handler of handlers.values()) {
+      try {
+        handler(error);
+      } catch {
       }
     }
   }
+  /**
+   * Re-run the subscribe handshake for one already-tracked room. Shared by
+   * reconnect resubscription (`resubscribeAll`) and the #661
+   * `subscription-invalidated` handler.
+   *
+   * - Deduped per room via `resubscribingRooms` so the duplicate invalidation
+   *   events the gateway emits (one per evicted room) collapse to one handshake.
+   * - Snapshots the room's generation; the ack acts only if it is still current,
+   *   so a late ack cannot clobber an unsubscribe/re-subscribe that happened in
+   *   the meantime — and a success that arrives after the room was removed emits
+   *   a compensating `unsubscribe` so no ghost server room is left behind.
+   * - On a genuine denial the subscription is evicted and its stored `onError`
+   *   is called (with the typed `.code`), instead of silently going quiet.
+   */
+  resubscribeRoom(room) {
+    if (!this.socket) return;
+    if (this.resubscribingRooms.has(room)) return;
+    if (!this.subscriptions.has(room)) return;
+    const parsed = this.parseRoom(room);
+    if (!parsed) return;
+    const { projectId, collectionName } = parsed;
+    const where = this.roomWhereMap.get(room);
+    const generation = this.roomGeneration.get(room) ?? 0;
+    const payload = { projectId, collectionName };
+    if (where) payload["where"] = where;
+    this.resubscribingRooms.add(room);
+    this.socket.emit(
+      "subscribe",
+      payload,
+      (response) => {
+        this.resubscribingRooms.delete(room);
+        if ((this.roomGeneration.get(room) ?? 0) !== generation) {
+          if (!this.subscriptions.has(room) && !response?.error) {
+            this.socket?.emit("unsubscribe", payload);
+          }
+          return;
+        }
+        if (response?.error) {
+          const error = this.toSubscribeError(response);
+          this.notifyRoomError(room, error);
+          this.subscriptions.delete(room);
+          this.roomWhereMap.delete(room);
+          this.roomErrorMap.delete(room);
+          this.roomGeneration.delete(room);
+        }
+      }
+    );
+  }
   emitSubscribeEvents(state) {
     return new Promise((resolve) => {
       if (!this.socket) {
@@ -2968,10 +3114,14 @@ var FunctionsModule = class {
    * `config.apiUrl` (which already carries the `/api/v1` prefix).
    *
    * Auth defaults, based on `invokeMode` semantics:
-   *  - webhook:       pass `secret` → Authorization is NOT attached
-   *  - authenticated: pass nothing  → Authorization IS attached (from token manager)
-   *  - public:        pass nothing  → Authorization is attached if logged in, else omitted
-   *  - hybrid:        pass both `secret` and `authenticated: true`
+   *  - webhook:                 pass `secret` → Authorization is NOT attached
+   *  - authenticated:           pass nothing  → Authorization IS attached (from token manager);
+   *                             caller must be a member of the target project
+   *  - public:                  pass nothing  → Authorization is attached if logged in, else omitted
+   *  - hybrid:                  pass both `secret` and `authenticated: true`; JWT path
+   *                             requires project membership like `authenticated`
+   *  - platform-authenticated:  pass nothing  → Authorization IS attached (from token manager);
+   *                             any signed-in user is accepted, still just attaches the bearer token
    *
    * To force a specific behaviour, set `authenticated` explicitly — it wins
    * over the `secret`-based default.