@stream-io/feeds-client 0.2.4 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {

package/src/common/real-time/event-models.ts

@@ -36,3 +36,19 @@ export interface ConnectedEvent {
    */
   type: string;
 }
+
+export enum UnhandledErrorType {
+  ReconnectionReconciliation = 'reconnection-reconciliation',
+}
+
+export type SyncFailure = { feed: string, reason: unknown };
+
+export type UnhandledErrorEvent = {
+  type: 'errors.unhandled';
+  error_type: UnhandledErrorType;
+} & (
+  | {
+      error_type: UnhandledErrorType.ReconnectionReconciliation;
+      failures: SyncFailure[];
+    }
+);

package/src/feed/event-handlers/feed/handle-feed-updated.ts

@@ -1,9 +1,9 @@
 import { Feed } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import { EventPayload, PartializeAllBut } from '../../../types-internal';
 
 export function handleFeedUpdated(
   this: Feed,
-  event: EventPayload<'feeds.feed.updated'>,
+  event: PartializeAllBut<EventPayload<'feeds.feed.updated'>, 'feed'>,
 ) {
   this.state.partialNext({ ...event.feed });
 }

package/src/feeds-client/feeds-client.ts

@@ -37,6 +37,7 @@ import { ModerationClient } from '../moderation-client';
 import { StreamPoll } from '../common/Poll';
 import {
   Feed,
+  handleFeedUpdated,
   handleFollowCreated,
   handleFollowDeleted,
   handleFollowUpdated,
@@ -44,6 +45,10 @@ import {
   handleWatchStopped,
 } from '../feed';
 import { handleUserUpdated } from './event-handlers';
+import {
+  SyncFailure,
+  UnhandledErrorType,
+} from '../common/real-time/event-models';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -100,14 +105,7 @@ export class FeedsClient extends FeedsApi {
           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)) {
               handleWatchStopped.bind(activeFeed)();
@@ -208,6 +206,31 @@ export class FeedsClient extends FeedsApi {
     });
   }
 
+  private 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: SyncFailure[] = 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,
+      });
+    }
+  };
+
   public pollFromState = (id: string) => this.polls_by_id.get(id);
 
   public hydratePollCache(activities: ActivityResponse[]) {
@@ -353,8 +376,13 @@ export class FeedsClient extends FeedsApi {
   async queryFeeds(request?: QueryFeedsRequest) {
     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 {
@@ -458,17 +486,20 @@ export class FeedsClient extends FeedsApi {
     watch?: boolean,
   ) => {
     const fid = `${group}:${id}`;
-    if (this.activeFeeds[fid]) {
-      const feed = this.activeFeeds[fid];
-      if (watch && !feed.currentState.watch) {
-        handleWatchStarted.bind(feed)();
-      }
-      return feed;
-    } else {
-      const feed = new Feed(this, group, id, data, watch);
-      this.activeFeeds[fid] = feed;
-      return feed;
+
+    if (!this.activeFeeds[fid]) {
+      this.activeFeeds[fid] = new Feed(this, group, id, data, watch);
     }
+
+    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;
   };
 
   private findActiveFeedByActivityId(activityId: string) {

package/src/types.ts

@@ -1,4 +1,7 @@
-import { ConnectionChangedEvent } from './common/real-time/event-models';
+import {
+  ConnectionChangedEvent,
+  UnhandledErrorEvent,
+} from './common/real-time/event-models';
 import { NetworkChangedEvent } from './common/types';
 import {
   PagerResponse,
@@ -10,7 +13,7 @@ import type {
 } from './gen/models';
 import { FeedsClient } from './feeds-client';
 
-export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent;
+export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent | UnhandledErrorEvent;
 export type ActivityIdOrCommentId = string;
 
 export type GetCommentsRequest = Parameters<FeedsClient['getComments']>[0];