@stream-io/feeds-client 0.1.10 → 0.2.0

package/src/feed/index.ts

@@ -0,0 +1,2 @@
+export * from './feed';
+export * from './event-handlers';

package/src/feeds-client/event-handlers/index.ts

@@ -0,0 +1 @@
+export * from './user/handle-user-updated';

package/src/feeds-client/event-handlers/user/handle-user-updated.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, beforeEach, expect } from 'vitest';
+
+import { FeedsClient, handleUserUpdated } from '../..';
+import { generateOwnUser, generateUserResponse } from '../../../test-utils';
+import { EventPayload } from '../../../types-internal';
+
+describe('handleUserUpdated', () => {
+  let feedsClient: FeedsClient;
+
+  beforeEach(() => {
+    feedsClient = new FeedsClient('mock-api-key');
+    const connectedUser = generateOwnUser();
+
+    feedsClient.state.partialNext({ connected_user: connectedUser });
+  });
+
+  it('should update the connected user in the state', () => {
+    const stateBefore = feedsClient.state.getLatestValue();
+
+    const event: EventPayload<'user.updated'> = {
+      type: 'user.updated',
+      created_at: new Date(),
+      custom: {},
+      user: {
+        ...generateUserResponse(),
+        ...stateBefore.connected_user!,
+      },
+    };
+
+    handleUserUpdated.call(feedsClient, event);
+
+    const stateAfter = feedsClient.state.getLatestValue();
+
+    expect(stateAfter.connected_user).toMatchObject({ name: event.user.name });
+  });
+
+  it('should not update the connected user if the incoming event contains other user', () => {
+    const event: EventPayload<'user.updated'> = {
+      type: 'user.updated',
+      created_at: new Date(),
+      custom: {},
+      user: generateUserResponse(),
+    };
+
+    const stateBefore = feedsClient.state.getLatestValue();
+
+    handleUserUpdated.call(feedsClient, event);
+
+    const stateAfter = feedsClient.state.getLatestValue();
+
+    expect(stateAfter.connected_user).toBe(stateBefore.connected_user);
+  });
+});

package/src/feeds-client/event-handlers/user/handle-user-updated.ts

@@ -0,0 +1,28 @@
+import type { EventPayload } from '../../../types-internal';
+import type { FeedsClient, FeedsClientState } from '../../feeds-client';
+
+export function handleUserUpdated(
+  this: FeedsClient,
+  event: EventPayload<'user.updated'>,
+) {
+  this.state.next((currentState) => {
+    let newState: FeedsClientState | undefined;
+
+    const { connected_user } = currentState;
+
+    if (connected_user && connected_user.id === event.user.id) {
+      newState ??= {
+        ...currentState,
+      };
+
+      newState.connected_user = {
+        ...connected_user,
+        ...event.user,
+      };
+    }
+
+    // TODO: update other users in user map (if/once applicable)
+
+    return newState ?? currentState;
+  });
+}

package/src/{FeedsClient.ts → feeds-client/feeds-client.ts}

@@ -1,40 +1,49 @@
-import { FeedsApi } from './gen/feeds/FeedsApi';
+import { FeedsApi } from '../gen/feeds/FeedsApi';
 import {
   ActivityResponse,
   FeedResponse,
   FileUploadRequest,
   FollowBatchRequest,
+  FollowRequest,
   ImageUploadRequest,
   OwnUser,
   PollResponse,
   PollVotesResponse,
   QueryFeedsRequest,
   QueryPollVotesRequest,
-  SingleFollowRequest,
+  UpdateFollowRequest,
   UserRequest,
   WSEvent,
-} from './gen/models';
-import { FeedsEvent, StreamFile, TokenOrProvider } from './types';
-import { StateStore } from './common/StateStore';
-import { TokenManager } from './common/TokenManager';
-import { ConnectionIdManager } from './common/ConnectionIdManager';
-import { StableWSConnection } from './common/real-time/StableWSConnection';
-import { EventDispatcher } from './common/EventDispatcher';
-import { ApiClient } from './common/ApiClient';
+} from '../gen/models';
+import { FeedsEvent, StreamFile, TokenOrProvider } from '../types';
+import { StateStore } from '../common/StateStore';
+import { TokenManager } from '../common/TokenManager';
+import { ConnectionIdManager } from '../common/ConnectionIdManager';
+import { StableWSConnection } from '../common/real-time/StableWSConnection';
+import { EventDispatcher } from '../common/EventDispatcher';
+import { ApiClient } from '../common/ApiClient';
 import {
   addConnectionEventListeners,
   removeConnectionEventListeners,
   streamDevToken,
-} from './common/utils';
-import { decodeWSEvent } from './gen/model-decoders/event-decoder-mapping';
-import { Feed } from './Feed';
+} from '../common/utils';
+import { decodeWSEvent } from '../gen/model-decoders/event-decoder-mapping';
 import {
   FeedsClientOptions,
   NetworkChangedEvent,
   StreamResponse,
-} from './common/types';
-import { ModerationClient } from './ModerationClient';
-import { StreamPoll } from './common/Poll';
+} from '../common/types';
+import { ModerationClient } from '../moderation-client';
+import { StreamPoll } from '../common/Poll';
+import {
+  Feed,
+  handleFollowCreated,
+  handleFollowDeleted,
+  handleFollowUpdated,
+  handleWatchStarted,
+  handleWatchStopped,
+} from '../feed';
+import { handleUserUpdated } from './event-handlers';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -101,7 +110,7 @@ export class FeedsClient extends FeedsApi {
             }
           } else {
             for (const activeFeed of Object.values(this.activeFeeds)) {
-              activeFeed.handleWatchStopped();
+              handleWatchStopped.bind(activeFeed)();
             }
           }
           break;
@@ -188,6 +197,10 @@ export class FeedsClient extends FeedsApi {
 
           break;
         }
+        case 'user.updated': {
+          handleUserUpdated.call(this, event);
+          break;
+        }
         default: {
           feed?.handleWSEvent(event as unknown as WSEvent);
         }
@@ -338,7 +351,7 @@ export class FeedsClient extends FeedsApi {
   };
 
   async queryFeeds(request?: QueryFeedsRequest) {
-    const response = await this.feedsQueryFeeds(request);
+    const response = await this._queryFeeds(request);
 
     const feeds = response.feeds.map((f) =>
       this.getOrCreateActiveFeed(f.group_id, f.id, f, request?.watch),
@@ -363,18 +376,35 @@ export class FeedsClient extends FeedsApi {
     this.eventDispatcher.dispatch(networkEvent);
   };
 
+  async updateFollow(request: UpdateFollowRequest) {
+    const response = await super.updateFollow(request);
+
+    [
+      response.follow.source_feed.feed,
+      response.follow.target_feed.feed,
+    ].forEach((fid) => {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFollowUpdated.bind(feed)(response);
+      }
+    });
+
+    return response;
+  }
+
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
-  async follow(request: SingleFollowRequest) {
+  async follow(request: FollowRequest) {
     const response = await super.follow(request);
 
-    [response.follow.source_feed.fid, response.follow.target_feed.fid].forEach(
-      (fid) => {
-        const feed = this.activeFeeds[fid];
-        if (feed) {
-          feed.handleFollowCreated(response.follow);
-        }
-      },
-    );
+    [
+      response.follow.source_feed.feed,
+      response.follow.target_feed.feed,
+    ].forEach((fid) => {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFollowCreated.bind(feed)(response);
+      }
+    });
 
     return response;
   }
@@ -383,25 +413,22 @@ export class FeedsClient extends FeedsApi {
     const response = await super.followBatch(request);
 
     response.follows.forEach((follow) => {
-      const feed = this.activeFeeds[follow.source_feed.fid];
+      const feed = this.activeFeeds[follow.source_feed.feed];
       if (feed) {
-        feed.handleFollowCreated(follow);
+        handleFollowCreated.bind(feed)({ follow });
       }
     });
 
     return response;
   }
 
-  async unfollow(request: SingleFollowRequest) {
+  async unfollow(request: FollowRequest) {
     const response = await super.unfollow(request);
 
     [request.source, request.target].forEach((fid) => {
       const feed = this.activeFeeds[fid];
       if (feed) {
-        feed.handleFollowDeleted({
-          source_feed: { fid: request.source },
-          target_feed: { fid: request.target },
-        });
+        handleFollowDeleted.bind(feed)(response);
       }
     });
 
@@ -418,7 +445,7 @@ export class FeedsClient extends FeedsApi {
     const feed =
       this.activeFeeds[`${request.feed_group_id}:${request.feed_id}`];
     if (feed) {
-      feed.handleWatchStopped();
+      handleWatchStopped.bind(feed)();
     }
 
     return response;
@@ -434,7 +461,7 @@ export class FeedsClient extends FeedsApi {
     if (this.activeFeeds[fid]) {
       const feed = this.activeFeeds[fid];
       if (watch && !feed.currentState.watch) {
-        feed.handleWatchStarted();
+        handleWatchStarted.bind(feed)();
       }
       return feed;
     } else {

package/src/feeds-client/index.ts

@@ -0,0 +1,2 @@
+export * from './feeds-client';
+export * from './event-handlers';