@stream-io/feeds-client 0.1.8 → 0.1.9

package/src/state-updates/follow-utils.ts

@@ -0,0 +1,126 @@
+import { FeedState } from '../Feed';
+import { FollowResponse, FeedResponse } from '../gen/models';
+import { UpdateStateResult } from '../types-internal';
+
+const isFeedResponse = (
+  follow: FeedResponse | { fid: string },
+): follow is FeedResponse => {
+  return 'created_by' in follow;
+};
+
+export const handleFollowCreated = (
+  follow: FollowResponse,
+  currentState: FeedState,
+  currentFeedId: string,
+  connectedUserId?: string,
+): UpdateStateResult<{ data: FeedState }> => {
+  // filter non-accepted follows (the way getOrCreate does by default)
+  if (follow.status !== 'accepted') {
+    return { changed: false, data: currentState };
+  }
+
+  let newState: FeedState = { ...currentState };
+
+  // this feed followed someone
+  if (follow.source_feed.fid === currentFeedId) {
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.source_feed,
+    };
+
+    // Only update if following array already exists
+    if (currentState.following !== undefined) {
+      newState.following = [follow, ...currentState.following];
+    }
+  } else if (
+    // someone followed this feed
+    follow.target_feed.fid === currentFeedId
+  ) {
+    const source = follow.source_feed;
+
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.target_feed,
+    };
+
+    if (source.created_by.id === connectedUserId) {
+      newState.own_follows = currentState.own_follows
+        ? currentState.own_follows.concat(follow)
+        : [follow];
+    }
+
+    // Only update if followers array already exists
+    if (currentState.followers !== undefined) {
+      newState.followers = [follow, ...currentState.followers];
+    }
+  }
+
+  return { changed: true, data: newState };
+};
+
+export const handleFollowDeleted = (
+  follow:
+    | FollowResponse
+    | { source_feed: { fid: string }; target_feed: { fid: string } },
+  currentState: FeedState,
+  currentFeedId: string,
+  connectedUserId?: string,
+): UpdateStateResult<{ data: FeedState }> => {
+  let newState: FeedState = { ...currentState };
+
+  // this feed unfollowed someone
+  if (follow.source_feed.fid === currentFeedId) {
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.source_feed,
+    };
+
+    // Only update if following array already exists
+    if (currentState.following !== undefined) {
+      newState.following = currentState.following.filter(
+        (followItem) => followItem.target_feed.fid !== follow.target_feed.fid,
+      );
+    }
+  } else if (
+    // someone unfollowed this feed
+    follow.target_feed.fid === currentFeedId
+  ) {
+    const source = follow.source_feed;
+
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.target_feed,
+    };
+
+    if (
+      isFeedResponse(source) &&
+      source.created_by.id === connectedUserId &&
+      currentState.own_follows !== undefined
+    ) {
+      newState.own_follows = currentState.own_follows.filter(
+        (followItem) => followItem.source_feed.fid !== follow.source_feed.fid,
+      );
+    }
+
+    // Only update if followers array already exists
+    if (currentState.followers !== undefined) {
+      newState.followers = currentState.followers.filter(
+        (followItem) => followItem.source_feed.fid !== follow.source_feed.fid,
+      );
+    }
+  }
+
+  return { changed: true, data: newState };
+};
+
+export const handleFollowUpdated = (
+  currentState: FeedState,
+): UpdateStateResult<{ data: FeedState }> => {
+  // For now, we'll treat follow updates as no-ops since the current implementation does
+  // This can be enhanced later if needed
+  return { changed: false, data: currentState };
+};

package/src/state-updates/state-update-queue.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+
+import { shouldUpdateState } from './state-update-queue';
+
+describe('state-update-queue', () => {
+  describe('shouldUpdateState', () => {
+    it('should return true when watch is false', () => {
+      const result = shouldUpdateState({
+        stateUpdateId: 'test-id',
+        stateUpdateQueue: new Set(['other-id']),
+        watch: false,
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true when watch is true but stateUpdateId is not in queue', () => {
+      const stateUpdateQueue = new Set(['other-id-1', 'other-id-2']);
+
+      const result = shouldUpdateState({
+        stateUpdateId: 'test-id',
+        stateUpdateQueue: stateUpdateQueue,
+        watch: true,
+      });
+
+      expect(stateUpdateQueue).toContain('test-id');
+      expect(result).toBe(true);
+    });
+
+    it('should return false and remove stateUpdateId from queue when watch is true and stateUpdateId is in queue', () => {
+      const stateUpdateQueue = new Set(['test-id', 'other-id']);
+
+      const result = shouldUpdateState({
+        stateUpdateId: 'test-id',
+        stateUpdateQueue,
+        watch: true,
+      });
+
+      expect(result).toBe(false);
+      expect(stateUpdateQueue).toEqual(new Set(['other-id']));
+    });
+
+    it('should handle empty queue when watch is true', () => {
+      const result = shouldUpdateState({
+        stateUpdateId: 'test-id',
+        stateUpdateQueue: new Set(),
+        watch: true,
+      });
+
+      expect(result).toBe(true);
+    });
+  });
+});

package/src/state-updates/state-update-queue.ts

@@ -0,0 +1,35 @@
+import { FollowResponse } from '../gen/models';
+
+export const shouldUpdateState = ({
+  stateUpdateId,
+  stateUpdateQueue,
+  watch,
+}: {
+  stateUpdateId: string;
+  stateUpdateQueue: Set<string>;
+  watch: boolean;
+}) => {
+  if (!watch) {
+    return true;
+  }
+
+  if (watch && stateUpdateQueue.has(stateUpdateId)) {
+    stateUpdateQueue.delete(stateUpdateId);
+    return false;
+  }
+
+  stateUpdateQueue.add(stateUpdateId);
+  return true;
+};
+
+export const getStateUpdateQueueIdForFollow = (follow: FollowResponse) => {
+  return `follow${follow.source_feed.fid}-${follow.target_feed.fid}`;
+};
+
+export const getStateUpdateQueueIdForUnfollow = (
+  follow:
+    | FollowResponse
+    | { source_feed: { fid: string }; target_feed: { fid: string } },
+) => {
+  return `unfollow${follow.source_feed.fid}-${follow.target_feed.fid}`;
+};

package/src/utils.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect } from 'vitest';
+
+import { uniqueArrayMerge } from './utils';
+
+describe('utils', () => {
+  describe('uniqueMerge', () => {
+    it('should merge arrays with unique objects based on key', () => {
+      const existingArray = [
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ];
+      const arrayToMerge = [
+        { id: '2', name: 'Bob Updated' },
+        { id: '3', name: 'Charlie' },
+      ];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+        { id: '3', name: 'Charlie' },
+      ]);
+    });
+
+    it('should preserve order of existing array and append new items', () => {
+      const existingArray = [
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ];
+      const arrayToMerge = [
+        { id: '3', name: 'Charlie' },
+        { id: '4', name: 'David' },
+      ];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+        { id: '3', name: 'Charlie' },
+        { id: '4', name: 'David' },
+      ]);
+    });
+
+    it('should filter out duplicate keys from array to merge', () => {
+      const existingArray = [
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ];
+      const arrayToMerge = [
+        { id: '1', name: 'Alice Updated' },
+        { id: '2', name: 'Bob Updated' },
+        { id: '3', name: 'Charlie' },
+      ];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+        { id: '3', name: 'Charlie' },
+      ]);
+    });
+
+    it('should handle empty existing array', () => {
+      const existingArray: Array<{ id: string; name: string }> = [];
+      const arrayToMerge = [
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ]);
+    });
+
+    it('should handle empty array to merge', () => {
+      const existingArray = [
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ];
+      const arrayToMerge: Array<{ id: string; name: string }> = [];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ]);
+    });
+
+    it('should handle both arrays being empty', () => {
+      const existingArray: Array<{ id: string; name: string }> = [];
+      const arrayToMerge: Array<{ id: string; name: string }> = [];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should work with different key functions', () => {
+      const existingArray = [
+        { id: '1', name: 'Alice', email: 'alice@example.com' },
+        { id: '2', name: 'Bob', email: 'bob@example.com' },
+      ];
+      const arrayToMerge = [
+        { id: '3', name: 'Charlie', email: 'alice@example.com' },
+        { id: '4', name: 'David', email: 'david@example.com' },
+      ];
+      const getKeyByEmail = (item: {
+        id: string;
+        name: string;
+        email: string;
+      }) => item.email;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKeyByEmail);
+
+      expect(result).toEqual([
+        { id: '1', name: 'Alice', email: 'alice@example.com' },
+        { id: '2', name: 'Bob', email: 'bob@example.com' },
+        { id: '4', name: 'David', email: 'david@example.com' },
+      ]);
+    });
+
+    it('should handle complex nested objects', () => {
+      const existingArray = [
+        { id: '1', data: { nested: { value: 'a' } } },
+        { id: '2', data: { nested: { value: 'b' } } },
+      ];
+      const arrayToMerge = [
+        { id: '2', data: { nested: { value: 'b_updated' } } },
+        { id: '3', data: { nested: { value: 'c' } } },
+      ];
+      const getKey = (item: {
+        id: string;
+        data: { nested: { value: string } };
+      }) => item.id;
+
+      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(result).toEqual([
+        { id: '1', data: { nested: { value: 'a' } } },
+        { id: '2', data: { nested: { value: 'b' } } },
+        { id: '3', data: { nested: { value: 'c' } } },
+      ]);
+    });
+
+    it('should preserve original arrays (immutability)', () => {
+      const existingArray = [
+        { id: '1', name: 'Alice' },
+        { id: '2', name: 'Bob' },
+      ];
+      const arrayToMerge = [{ id: '3', name: 'Charlie' }];
+      const getKey = (item: { id: string; name: string }) => item.id;
+
+      const originalExisting = [...existingArray];
+      const originalToMerge = [...arrayToMerge];
+
+      uniqueArrayMerge(existingArray, arrayToMerge, getKey);
+
+      expect(existingArray).toEqual(originalExisting);
+      expect(arrayToMerge).toEqual(originalToMerge);
+    });
+  });
+});

package/src/utils.ts

@@ -26,3 +26,23 @@ export const isCommentResponse = (
 export const Constants = {
   DEFAULT_COMMENT_PAGINATION: 'first',
 } as const;
+
+export const uniqueArrayMerge = <T>(
+  existingArray: T[],
+  arrayToMerge: T[],
+  getKey: (v: T) => string,
+) => {
+  const existing = new Set<string>();
+
+  existingArray.forEach((value) => {
+    const key = getKey(value);
+    existing.add(key);
+  });
+
+  const filteredArrayToMerge = arrayToMerge.filter((value) => {
+    const key = getKey(value);
+    return !existing.has(key);
+  });
+
+  return existingArray.concat(filteredArrayToMerge);
+};