lazypock 0.8.3 → 0.9.0

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   fieldTypeScriptType,
   generateTypes,
   schemaFieldType
-} from "./chunk-V2XSEOWF.js";
+} from "./chunk-CGQVJ7TT.js";
 
 // src/types.ts
 var ApiError = class extends Error {
@@ -781,25 +781,24 @@ var CollectionService = class _CollectionService {
     derived.fieldsPreset = this.fieldsPreset;
     return derived;
   }
-  // ── Realtime Subscriptions (PocketBase-style) ──
-  /**
-   * Subscribe to realtime changes for this collection.
-   * The event's `action` is one of `"create" | "update" | "delete"`.
-   *
-   * Access is governed by the collection's `listRule` (PocketBase semantics):
-   * public collections allow anonymous subscriptions; other collections
-   * require a matching logged-in user or superuser.
-   *
-   * @param callback Received on every record change.
-   * @param recordId Optional — subscribe to a single record instead of `*`.
-   * @returns A function that unsubscribes this callback.
-   */
-  subscribe(callback, recordId) {
+  subscribe(topicOrCallback, maybeCallback, options) {
     if (!this.realtime) {
       console.warn("[lazypock] No realtime service configured.");
       return () => {
       };
     }
+    let recordId;
+    let callback;
+    let joinPayload;
+    if (typeof topicOrCallback === "function") {
+      callback = topicOrCallback;
+      if (typeof maybeCallback === "string") recordId = maybeCallback;
+    } else {
+      callback = maybeCallback;
+      recordId = topicOrCallback === "*" ? void 0 : topicOrCallback;
+      const { headers: _ignored, ...rest } = options ?? {};
+      if (Object.keys(rest).length > 0) joinPayload = rest;
+    }
     const topic = "collection:" + this.collectionName + (recordId ? ":" + recordId : "");
     const handler = (raw) => {
       const record = raw.payload?.["record"] ?? {};
@@ -810,15 +809,23 @@ var CollectionService = class _CollectionService {
       });
     };
     this.realtime.ensureConnected();
-    this.realtime.subscribe(topic, handler);
+    this.realtime.subscribe(topic, handler, joinPayload);
     return () => this.realtime?.unsubscribe(topic, handler);
   }
   /**
-   * Unsubscribe all callbacks from this collection (or a specific record).
-   * @param recordId Optional record id; omitting it unsubs everything.
+   * Unsubscribe from realtime changes (PocketBase-compatible):
+   *   - `unsubscribe()` — remove **all** subscriptions of this collection
+   *   - `unsubscribe('*')` — remove wildcard subscriptions
+   *   - `unsubscribe('RECORD_ID')` — remove that record's subscriptions
    */
   unsubscribe(recordId) {
-    const topic = "collection:" + this.collectionName + (recordId ? ":" + recordId : "");
+    if (recordId === void 0) {
+      this.realtime?.unsubscribeByPrefix(
+        "collection:" + this.collectionName
+      );
+      return;
+    }
+    const topic = "collection:" + this.collectionName + (recordId === "*" ? "" : ":" + recordId);
     this.realtime?.unsubscribe(topic);
   }
   // ── Auth Collection Methods ──
@@ -885,6 +892,7 @@ var RealtimeService = class {
     this.reconnectAttempt = 0;
     this.maxReconnectDelay = 5e3;
     this.url = "";
+    this.tokenProvider = null;
     // ── Heartbeat ──
     this.heartbeatInterval = null;
   }
@@ -910,6 +918,32 @@ var RealtimeService = class {
   setUrl(url) {
     this.url = url;
   }
+  /**
+   * Register a token provider consulted at every (re)connect.
+   * When set, it takes precedence over the token passed to {@link connect}.
+   */
+  setTokenProvider(provider) {
+    this.tokenProvider = provider;
+  }
+  /**
+   * Reconnect the socket immediately with the current token.
+   * Called by the SDK when auth changes (login/logout/token refresh) so
+   * private-channel joins are authorized with the new credentials. No-op
+   * when the socket has never been opened and nothing is subscribed.
+   */
+  refresh() {
+    if (typeof WebSocket === "undefined") return;
+    if (!this.ws && this.subscriptions.size === 0) return;
+    this.clearReconnectTimer();
+    const ws = this.ws;
+    this.ws = null;
+    if (ws) {
+      ws.onclose = null;
+      ws.close();
+    }
+    this.reconnectAttempt = 0;
+    this.doConnect();
+  }
   /*
    * Ensure the socket is connected, then subscribe.
    * Used by collection-level convenience wrappers so a connection is opened
@@ -933,15 +967,30 @@ var RealtimeService = class {
     this.ws = null;
   }
   /**
-   * Subscribe to a topic (e.g. "collection:posts" or "collection:posts:*").
+   * Subscribe to a topic (e.g. "collection:posts" or "custom:chat-room").
    * The backend Channel authorizes via listRule on join.
+   *
+   * @param joinPayload Optional payload forwarded with the channel join
+   * (available to the server's join callback / hooks, e.g. `expand`).
    */
-  subscribe(topic, callback) {
+  subscribe(topic, callback, joinPayload) {
     const subs = this.subscriptions.get(topic) || [];
-    subs.push({ topic, callback });
+    subs.push({ topic, callback, joinPayload });
     this.subscriptions.set(topic, subs);
     if (this.ws?.readyState === WebSocket.OPEN) {
-      this.joinTopic(topic);
+      this.joinTopic(topic, joinPayload);
+    }
+  }
+  /**
+   * Remove all subscriptions for topics under `prefix` (the topic itself or
+   * any topic starting with `prefix + ":"`). Used by collection-level
+   * `unsubscribe()` to drop every subscription of a collection.
+   */
+  unsubscribeByPrefix(prefix) {
+    for (const topic of [...this.subscriptions.keys()]) {
+      if (topic === prefix || topic.startsWith(prefix + ":")) {
+        this.subscriptions.delete(topic);
+      }
     }
   }
   /**
@@ -960,9 +1009,14 @@ var RealtimeService = class {
     }
   }
   resubscribeAll() {
-    for (const topic of this.subscriptions.keys()) {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.joinTopic(topic);
+    const seen = /* @__PURE__ */ new Set();
+    for (const entries of this.subscriptions.values()) {
+      for (const entry of entries) {
+        if (seen.has(entry.topic)) continue;
+        seen.add(entry.topic);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.joinTopic(entry.topic, entry.joinPayload);
+        }
       }
     }
   }
@@ -974,8 +1028,9 @@ var RealtimeService = class {
       return;
     }
     let url = this.url;
-    if (this.token) {
-      url += (url.includes("?") ? "&" : "?") + "token=" + encodeURIComponent(this.token);
+    const token = this.tokenProvider ? this.tokenProvider() : this.token;
+    if (token) {
+      url += (url.includes("?") ? "&" : "?") + "token=" + encodeURIComponent(token);
     }
     this.ws = new WebSocket(url);
     this.ws.onopen = () => {
@@ -1022,12 +1077,12 @@ var RealtimeService = class {
       }
     }
   }
-  joinTopic(topic) {
+  joinTopic(topic, joinPayload) {
     const ref = this.nextRef();
     const msg = JSON.stringify({
       topic,
       event: "phx_join",
-      payload: {},
+      payload: joinPayload ?? {},
       ref
     });
     this.ws?.send(msg);
@@ -1333,6 +1388,9 @@ var LazypockClient = class {
     if (!options.realtime) {
       this.realtime.setUrl(wsUrlFromBaseUrl(baseUrl));
     }
+    this.realtime.setTokenProvider(() => this.authStore.token);
+    this.authStore.onChange(() => this.realtime.refresh());
+    this.authReady.then(() => this.realtime.refresh());
     this.files = new FilesService(this.http);
     this.collections = new CollectionsService(this.http, this.realtime);
     if (options.types?.schemas) {