@stream-io/feeds-client 0.2.17 → 0.2.19

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

@@ -14,6 +14,7 @@ import type {
   FollowBatchRequest,
   FollowRequest,
   ImageUploadRequest,
+  OwnCapabilitiesBatchRequest,
   OwnUser,
   PollResponse,
   PollVotesResponse,
@@ -66,15 +67,26 @@ import {
   handleWatchStopped,
 } from '../feed';
 import { handleUserUpdated } from './event-handlers';
-import type { SyncFailure } from '../common/real-time/event-models';
-import { UnhandledErrorType } from '../common/real-time/event-models';
+import {
+  type SyncFailure,
+  UnhandledErrorType,
+} from '../common/real-time/event-models';
 import { updateCommentCount } from '../feed/event-handlers/comment/utils';
 import { configureLoggers } from '../utils';
 import { handleCommentReactionUpdated } from '../feed/event-handlers/comment/handle-comment-reaction-updated';
+import {
+  throttle,
+  DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL,
+  type GetBatchedOwnCapabilitiesThrottledCallback,
+  queueBatchedOwnCapabilities,
+  type ThrottledGetBatchedOwnCapabilities,
+  clearQueuedFeeds,
+} from '../utils/throttling';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
   is_ws_connection_healthy: boolean;
+  own_capabilities_by_fid: Record<string, FeedResponse['own_capabilities']>;
 };
 
 type FID = string;
@@ -97,6 +109,10 @@ export class FeedsClient extends FeedsApi {
 
   private healthyConnectionChangedEventCount = 0;
 
+  protected throttledGetBatchOwnCapabilities!: ThrottledGetBatchedOwnCapabilities;
+  private cancelGetBatchOwnCapabilitiesTimer!: () => void;
+  private query_batch_own_capabilties_throttling_interval!: number;
+
   constructor(apiKey: string, options?: FeedsClientOptions) {
     const tokenManager = new TokenManager();
     const connectionIdManager = new ConnectionIdManager();
@@ -110,12 +126,17 @@ export class FeedsClient extends FeedsApi {
     this.state = new StateStore<FeedsClientState>({
       connected_user: undefined,
       is_ws_connection_healthy: false,
+      own_capabilities_by_fid: {},
     });
     this.moderation = new ModerationClient(apiClient);
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
     this.polls_by_id = new Map();
 
+    this.query_batch_own_capabilties_throttling_interval =
+      options?.query_batch_own_capabilties_throttling_interval ??
+      DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL;
+
     configureLoggers(options?.configure_loggers_options);
 
     this.on('all', (event) => {
@@ -231,6 +252,32 @@ export class FeedsClient extends FeedsApi {
     });
   }
 
+  private setGetBatchOwnCapabilitiesThrottlingInterval = (
+    throttlingMs: number,
+  ) => {
+    const {
+      throttledFn: throttledGetBatchOwnCapabilities,
+      cancelTimer: cancel,
+    } = throttle<GetBatchedOwnCapabilitiesThrottledCallback>(
+      (feeds, callback) => {
+        this.ownCapabilitiesBatch({
+          feeds,
+        }).catch((error) => {
+          this.eventDispatcher.dispatch({
+            type: 'errors.unhandled',
+            error_type: UnhandledErrorType.FetchingOwnCapabilitiesOnNewActivity,
+            error,
+          });
+        });
+        callback(feeds);
+      },
+      throttlingMs,
+      { trailing: true },
+    );
+    this.throttledGetBatchOwnCapabilities = throttledGetBatchOwnCapabilities;
+    this.cancelGetBatchOwnCapabilitiesTimer = cancel;
+  };
+
   private recoverOnReconnect = async () => {
     this.healthyConnectionChangedEventCount++;
 
@@ -276,6 +323,34 @@ export class FeedsClient extends FeedsApi {
     }
   }
 
+  public hydrateCapabilitiesCache(
+    feedResponses: Array<Pick<FeedResponse, 'feed' | 'own_capabilities'>>,
+  ) {
+    let ownCapabilitiesCache =
+      this.state.getLatestValue().own_capabilities_by_fid;
+
+    const capabilitiesToFetchQueue: string[] = [];
+
+    for (const feedResponse of feedResponses) {
+      const { feed, own_capabilities } = feedResponse;
+
+      if (!Object.prototype.hasOwnProperty.call(ownCapabilitiesCache, feed)) {
+        if (own_capabilities) {
+          ownCapabilitiesCache = {
+            ...ownCapabilitiesCache,
+            [feed]: own_capabilities,
+          };
+        } else {
+          capabilitiesToFetchQueue.push(feed);
+        }
+      }
+    }
+
+    queueBatchedOwnCapabilities.bind(this)({ feeds: capabilitiesToFetchQueue });
+
+    this.state.partialNext({ own_capabilities_by_fid: ownCapabilitiesCache });
+  }
+
   connectUser = async (user: UserRequest, tokenProvider: TokenOrProvider) => {
     if (
       this.state.getLatestValue().connected_user !== undefined ||
@@ -286,6 +361,10 @@ export class FeedsClient extends FeedsApi {
 
     this.tokenManager.setTokenOrProvider(tokenProvider);
 
+    this.setGetBatchOwnCapabilitiesThrottlingInterval(
+      this.query_batch_own_capabilties_throttling_interval,
+    );
+
     try {
       addConnectionEventListeners(this.updateNetworkConnectionStatus);
       this.wsConnection = new StableWSConnection(
@@ -516,23 +595,43 @@ export class FeedsClient extends FeedsApi {
 
     this.connectionIdManager.reset();
     this.tokenManager.reset();
+
+    // clear all caches
+    this.polls_by_id.clear();
+
     this.state.partialNext({
       connected_user: undefined,
       is_ws_connection_healthy: false,
+      own_capabilities_by_fid: {},
     });
+
+    this.cancelGetBatchOwnCapabilitiesTimer();
+    clearQueuedFeeds();
   };
 
   on = this.eventDispatcher.on;
   off = this.eventDispatcher.off;
 
-  feed = (groupId: string, id: string) => {
-    return this.getOrCreateActiveFeed(groupId, id);
+  feed = (
+    groupId: string,
+    id: string,
+    options?: { addNewActivitiesTo?: 'start' | 'end' },
+  ) => {
+    return this.getOrCreateActiveFeed(
+      groupId,
+      id,
+      undefined,
+      undefined,
+      options?.addNewActivitiesTo,
+    );
   };
 
   async queryFeeds(request?: QueryFeedsRequest) {
     const response = await this._queryFeeds(request);
 
-    const feeds = response.feeds.map((feedResponse) =>
+    const feedResponses = response.feeds;
+
+    const feeds = feedResponses.map((feedResponse) =>
       this.getOrCreateActiveFeed(
         feedResponse.group_id,
         feedResponse.id,
@@ -541,6 +640,8 @@ export class FeedsClient extends FeedsApi {
       ),
     );
 
+    this.hydrateCapabilitiesCache(feedResponses);
+
     return {
       feeds,
       next: response.next,
@@ -550,6 +651,18 @@ export class FeedsClient extends FeedsApi {
     };
   }
 
+  async ownCapabilitiesBatch(request: OwnCapabilitiesBatchRequest) {
+    const response = await super.ownCapabilitiesBatch(request);
+    const feedResponses = Object.entries(response.capabilities).map(
+      ([feed, own_capabilities]) => ({
+        feed,
+        own_capabilities,
+      }),
+    );
+    this.hydrateCapabilitiesCache(feedResponses);
+    return response;
+  }
+
   updateNetworkConnectionStatus = (
     event: { type: 'online' | 'offline' } | Event,
   ) => {
@@ -640,11 +753,19 @@ export class FeedsClient extends FeedsApi {
     id: string,
     data?: FeedResponse,
     watch?: boolean,
+    addNewActivitiesTo?: 'start' | 'end',
   ) => {
     const fid = `${group}:${id}`;
 
     if (!this.activeFeeds[fid]) {
-      this.activeFeeds[fid] = new Feed(this, group, id, data, watch);
+      this.activeFeeds[fid] = new Feed(
+        this,
+        group,
+        id,
+        data,
+        watch,
+        addNewActivitiesTo,
+      );
     }
 
     const feed = this.activeFeeds[fid];

package/src/gen/feeds/FeedsApi.ts

@@ -170,6 +170,8 @@ export class FeedsApi {
     const body = {
       name: request?.name,
       words: request?.words,
+      is_leet_check_enabled: request?.is_leet_check_enabled,
+      is_plural_check_enabled: request?.is_plural_check_enabled,
       team: request?.team,
       type: request?.type,
     };
@@ -220,6 +222,8 @@ export class FeedsApi {
       name: request?.name,
     };
     const body = {
+      is_leet_check_enabled: request?.is_leet_check_enabled,
+      is_plural_check_enabled: request?.is_plural_check_enabled,
       team: request?.team,
       words: request?.words,
     };
@@ -499,6 +503,7 @@ export class FeedsApi {
       reason: request?.reason,
       report: request?.report,
       show_less: request?.show_less,
+      show_more: request?.show_more,
     };
 
     const response = await this.apiClient.sendRequest<

package/src/gen/model-decoders/decoders.ts

@@ -1233,9 +1233,11 @@ decoders.ModerationCustomActionEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    message: { type: 'Message', isSingle: true },
+    review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'MessageResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1266,9 +1268,11 @@ decoders.ModerationMarkReviewedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    message: { type: 'Message', isSingle: true },
+    item: { type: 'ReviewQueueItemResponse', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'MessageResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1745,6 +1749,8 @@ decoders.StoriesFeedUpdatedEvent = (input?: Record<string, any>) => {
 
     received_at: { type: 'DatetimeType', isSingle: true },
 
+    activities: { type: 'ActivityResponse', isSingle: false },
+
     aggregated_activities: {
       type: 'AggregatedActivityResponse',
       isSingle: false,