@stream-io/feeds-client 0.1.8 → 0.1.10

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);
+};