@stream-io/feeds-client 0.2.4 → 0.2.6

package/dist/index-react-bindings.node.cjs

@@ -1614,6 +1614,12 @@ decoders.UpsertConfigResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.UpsertPushPreferencesResponse = (input) => {
+    const typeMappings = {
+        user_preferences: { type: 'PushPreferences', isSingle: false },
+    };
+    return decode(typeMappings, input);
+};
 decoders.User = (input) => {
     const typeMappings = {
         ban_expires: { type: 'DatetimeType', isSingle: true },
@@ -1981,6 +1987,7 @@ class FeedsApi {
             text: request?.text,
             visibility: request?.visibility,
             attachments: request?.attachments,
+            feeds: request?.feeds,
             filter_tags: request?.filter_tags,
             interest_tags: request?.interest_tags,
             custom: request?.custom,
@@ -2610,6 +2617,14 @@ class FeedsApi {
         decoders.PollVotesResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
+    async updatePushNotificationPreferences(request) {
+        const body = {
+            preferences: request?.preferences,
+        };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/push_preferences', undefined, undefined, body, 'application/json');
+        decoders.UpsertPushPreferencesResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
     async deleteFile(request) {
         const queryParams = {
             url: request?.url,
@@ -5717,6 +5732,11 @@ function handleUserUpdated(event) {
     });
 }
 
+var UnhandledErrorType;
+(function (UnhandledErrorType) {
+    UnhandledErrorType["ReconnectionReconciliation"] = "reconnection-reconciliation";
+})(UnhandledErrorType || (UnhandledErrorType = {}));
+
 class FeedsClient extends FeedsApi {
     constructor(apiKey, options) {
         const tokenManager = new TokenManager();
@@ -5726,6 +5746,22 @@ class FeedsClient extends FeedsApi {
         this.eventDispatcher = new EventDispatcher();
         this.activeFeeds = {};
         this.healthyConnectionChangedEventCount = 0;
+        this.recoverOnReconnect = async () => {
+            this.healthyConnectionChangedEventCount++;
+            // we skip the first event as we could potentially be querying twice
+            if (this.healthyConnectionChangedEventCount > 1) {
+                const entries = Object.entries(this.activeFeeds);
+                const results = await Promise.allSettled(entries.map(([, feed]) => feed.synchronize()));
+                const failures = results.flatMap((result, index) => result.status === 'rejected'
+                    ? [{ feed: entries[index][0], reason: result.reason }]
+                    : []);
+                this.eventDispatcher.dispatch({
+                    type: 'errors.unhandled',
+                    error_type: UnhandledErrorType.ReconnectionReconciliation,
+                    failures,
+                });
+            }
+        };
         this.pollFromState = (id) => this.polls_by_id.get(id);
         this.connectUser = async (user, tokenProvider) => {
             if (this.state.getLatestValue().connected_user !== undefined ||
@@ -5821,18 +5857,18 @@ class FeedsClient extends FeedsApi {
         };
         this.getOrCreateActiveFeed = (group, id, data, watch) => {
             const fid = `${group}:${id}`;
-            if (this.activeFeeds[fid]) {
-                const feed = this.activeFeeds[fid];
-                if (watch && !feed.currentState.watch) {
-                    handleWatchStarted.bind(feed)();
-                }
-                return feed;
+            if (!this.activeFeeds[fid]) {
+                this.activeFeeds[fid] = new Feed(this, group, id, data, watch);
             }
-            else {
-                const feed = new Feed(this, group, id, data, watch);
-                this.activeFeeds[fid] = feed;
-                return feed;
+            const feed = this.activeFeeds[fid];
+            if (!feed.currentState.watch) {
+                // feed isn't watched and may be stale, update it
+                if (data)
+                    handleFeedUpdated.call(feed, { feed: data });
+                if (watch)
+                    handleWatchStarted.call(feed);
             }
+            return feed;
         };
         this.state = new StateStore({
             connected_user: undefined,
@@ -5850,13 +5886,7 @@ class FeedsClient extends FeedsApi {
                     const { online } = event;
                     this.state.partialNext({ is_ws_connection_healthy: online });
                     if (online) {
-                        this.healthyConnectionChangedEventCount++;
-                        // we skip the first event as we could potentially be querying twice
-                        if (this.healthyConnectionChangedEventCount > 1) {
-                            for (const activeFeed of Object.values(this.activeFeeds)) {
-                                activeFeed.synchronize();
-                            }
-                        }
+                        this.recoverOnReconnect();
                     }
                     else {
                         for (const activeFeed of Object.values(this.activeFeeds)) {
@@ -5970,7 +6000,7 @@ class FeedsClient extends FeedsApi {
     }
     async queryFeeds(request) {
         const response = await this._queryFeeds(request);
-        const feeds = response.feeds.map((f) => this.getOrCreateActiveFeed(f.group_id, f.id, f, request?.watch));
+        const feeds = response.feeds.map((feedResponse) => this.getOrCreateActiveFeed(feedResponse.group_id, feedResponse.id, feedResponse, request?.watch));
         return {
             feeds,
             next: response.next,