@stream-io/feeds-client 0.3.31 → 0.3.33

package/src/utils/check-own-fields-equality.ts

@@ -1,25 +1,25 @@
 import type { FeedState } from '../feed';
-import type { FeedResponse } from '../gen/models';
+import type { FeedResponse, FollowResponse } from '../gen/models';
 
-export const isOwnFollowsEqual = (
-  currentState: FeedState,
-  newState: FeedResponse,
-) => {
+const areFollowArraysEqual = (
+  currentFollows: FollowResponse[] | undefined,
+  newFollows: FollowResponse[] | undefined,
+): boolean => {
   const existingFollows = new Set(
-    currentState.own_follows?.map(
+    currentFollows?.map(
       (f) =>
         `${f.source_feed.feed}:${f.target_feed.feed}:${f.updated_at.getTime()}`,
     ),
   );
-  const newFollows = new Set(
-    newState.own_follows?.map(
+  const newFollowsSet = new Set(
+    newFollows?.map(
       (f) =>
         `${f.source_feed.feed}:${f.target_feed.feed}:${f.updated_at.getTime()}`,
     ),
   );
-  if (existingFollows.size === newFollows.size) {
+  if (existingFollows.size === newFollowsSet.size) {
     const areEqual = Array.from(existingFollows).every((f) =>
-      newFollows.has(f),
+      newFollowsSet.has(f),
     );
     if (areEqual) {
       return true;
@@ -29,6 +29,13 @@ export const isOwnFollowsEqual = (
   return false;
 };
 
+export const isOwnFollowsEqual = (
+  currentState: FeedState,
+  newState: FeedResponse,
+) => {
+  return areFollowArraysEqual(currentState.own_follows, newState.own_follows);
+};
+
 export const isOwnMembershipEqual = (
   currentState: FeedState,
   newState: FeedResponse,
@@ -38,3 +45,23 @@ export const isOwnMembershipEqual = (
     (newState.own_membership?.updated_at.getTime() ?? 0)
   );
 };
+
+export const isOwnCapabilitiesEqual = (
+  currentState: FeedState,
+  newState: FeedResponse,
+) => {
+  return (
+    [...(currentState.own_capabilities ?? [])].sort().join(',') ===
+    [...(newState.own_capabilities ?? [])].sort().join(',')
+  );
+};
+
+export const isOwnFollowingsEqual = (
+  currentState: FeedState,
+  newState: FeedResponse,
+) => {
+  return areFollowArraysEqual(
+    currentState.own_followings,
+    newState.own_followings,
+  );
+};

package/src/utils/throttling/index.ts

@@ -1,2 +1,2 @@
 export * from './throttle';
-export * from './throttled-get-batched-own-capabilities'
+export * from './throttled-get-batched-own-fields';

package/src/utils/throttling/{throttled-get-batched-own-capabilities.ts → throttled-get-batched-own-fields.ts}

@@ -1,35 +1,35 @@
 import type { FeedsClient } from '../../feeds-client';
 import type { ThrottledFunction } from './throttle';
 
-const BATCH_OWN_CAPABILITIES_API_LIMIT = 100;
+const BATCH_OWN_FIELDS_API_LIMIT = 100;
 
-export type GetBatchedOwnCapabilities = {
+export type GetBatchedOwnFields = {
   feeds: string[];
 };
 
-export type GetBatchedOwnCapabilitiesThrottledCallback = [
+export type GetBatchedOwnFieldsThrottledCallback = [
   feeds: string[],
   callback: (feedsToClear: string[]) => void | Promise<void>,
 ];
 
-export type ThrottledGetBatchedOwnCapabilities =
-  ThrottledFunction<GetBatchedOwnCapabilitiesThrottledCallback>;
+export type ThrottledGetBatchedOwnFields =
+  ThrottledFunction<GetBatchedOwnFieldsThrottledCallback>;
 
-export const DEFAULT_BATCH_OWN_CAPABILITIES_THROTTLING_INTERVAL = 2000;
+export const DEFAULT_BATCH_OWN_FIELDS_THROTTLING_INTERVAL = 2000;
 
 const queuedFeeds: Set<string> = new Set();
 
-export function queueBatchedOwnCapabilities(
+export function queueBatchedOwnFields(
   this: FeedsClient,
-  { feeds }: GetBatchedOwnCapabilities,
+  { feeds }: GetBatchedOwnFields,
 ) {
   for (const feed of feeds) {
     queuedFeeds.add(feed);
   }
 
   if (queuedFeeds.size > 0) {
-    this.throttledGetBatchOwnCapabilities(
-      [...queuedFeeds].slice(0, BATCH_OWN_CAPABILITIES_API_LIMIT),
+    this.throttledGetBatchOwnFields(
+      [...queuedFeeds].slice(0, BATCH_OWN_FIELDS_API_LIMIT),
       (feedsToClear: string[]) => {
         for (const feed of feedsToClear) {
           queuedFeeds.delete(feed);