@stream-io/feeds-client 0.2.18 → 0.2.19

package/src/feed/feed.test.ts

@@ -1,90 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { FeedsClient } from '../feeds-client';
-import { Feed } from './feed';
-import type { ActivityResponse } from '../gen/models';
-import { generateActivityResponse, generateFeedResponse } from '../test-utils';
-
-describe('Feed derived state updates', () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let activities: ActivityResponse[];
-
-  beforeEach(() => {
-    client = new FeedsClient('mock-api-key');
-    const feedResponse = generateFeedResponse({ id: 'main', group_id: 'user' });
-    feed = new Feed(
-      client,
-      feedResponse.group_id,
-      feedResponse.id,
-      feedResponse,
-    );
-    activities = [
-      generateActivityResponse(),
-      generateActivityResponse(),
-      generateActivityResponse(),
-    ];
-  });
-
-  it('should update the cache if activities change in feed.state', () => {
-    let indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(0);
-
-    feed.state.partialNext({ activities });
-
-    indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-  });
-
-  it('should update the cache if activities are further updated', () => {
-    // Include all of them
-    feed.state.partialNext({ activities });
-
-    let indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-
-    // Take only the last 2
-    const newActivities = activities.slice(1);
-    feed.state.partialNext({ activities: newActivities });
-
-    indexedActivityIds = (feed as any).indexedActivityIds;
-    expect((feed as any).indexedActivityIds.size).toEqual(2);
-    for (const activity of newActivities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-
-    // Include all of them again
-    feed.state.partialNext({ activities });
-
-    indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-  });
-
-  it('should not update the cache if the length of activities has not changed', () => {
-    feed.state.partialNext({ activities });
-
-    const indexedActivityIdsBefore = (feed as any).indexedActivityIds;
-    expect(indexedActivityIdsBefore.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIdsBefore.has(activity.id)).toBe(true);
-    }
-
-    const reversedActivities = activities.toReversed();
-    feed.state.partialNext({ activities: reversedActivities });
-
-    const indexedActivityIdsAfter = (feed as any).indexedActivityIds;
-    expect(indexedActivityIdsAfter.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIdsAfter.has(activity.id)).toBe(true);
-    }
-    expect(indexedActivityIdsBefore).toBe(indexedActivityIdsAfter);
-  });
-});

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

@@ -1,53 +0,0 @@
-import { describe, it, beforeEach, expect } from 'vitest';
-
-import { FeedsClient, handleUserUpdated } from '../..';
-import { generateOwnUser, generateUserResponse } from '../../../test-utils';
-import type { 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/utils/event-triggered-by-connected-user.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import { eventTriggeredByConnectedUser as eventTriggeredByConnectedUserInternal } from './event-triggered-by-connected-user';
-import { FeedsClient } from '../feeds-client';
-import { Feed } from '../feed';
-import {
-  generateFeedResponse,
-  generateOwnUser, generateUserResponse,
-  getHumanId,
-} from '../test-utils';
-
-describe('eventTriggeredByConnectedUser', () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let currentUserId: string;
-
-  let eventTriggeredByConnectedUser: OmitThisParameter<typeof eventTriggeredByConnectedUserInternal>
-
-  beforeEach(() => {
-    client = new FeedsClient('mock-api-key');
-    currentUserId = getHumanId();
-
-    client.state.partialNext({
-      connected_user: generateOwnUser({ id: currentUserId }),
-    });
-
-    const feedResponse = generateFeedResponse({
-      id: 'main',
-      group_id: 'user',
-      created_by: { id: currentUserId },
-    });
-
-    feed = new Feed(
-      client,
-      feedResponse.group_id,
-      feedResponse.id,
-      feedResponse,
-    );
-
-    eventTriggeredByConnectedUser = eventTriggeredByConnectedUserInternal.bind(feed);
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  })
-
-  it('returns true when payload.user.id matches connected_user.id', () => {
-    const user = generateUserResponse({ id: currentUserId });
-    const result = eventTriggeredByConnectedUser({ user });
-    expect(result).toBe(true);
-  });
-
-  it('returns true when payload.user is undefined and connected_user exists', () => {
-    const result = eventTriggeredByConnectedUser({});
-    expect(result).toBe(true);
-  });
-
-  it('returns false when payload.user.id differs from connected_user.id', () => {
-    const user = generateUserResponse({ id: getHumanId() });
-    const result = eventTriggeredByConnectedUser({ user });
-    expect(result).toBe(false);
-  });
-
-  it('returns false when connected_user is undefined (even if payload.user present)', () => {
-    // @ts-expect-error using protected value only in tests
-    feed.client.state.partialNext({ connected_user: undefined });
-    const user = generateUserResponse({ id: currentUserId });
-    const result1 = eventTriggeredByConnectedUser({ user });
-    const result2 = eventTriggeredByConnectedUser({});
-    expect(result1).toBe(false);
-    expect(result2).toBe(false);
-  });
-});

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

@@ -1,129 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { shouldUpdateState } from './state-update-queue';
-
-describe('state-update-queue', () => {
-  describe('shouldUpdateState', () => {
-    it('should return true when only watch is false', () => {
-      const result = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue: new Set(['ws-other-id']),
-        watch: false,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(result).toBe(true);
-    });
-
-    it('should return true when only isTriggeredByConnectedUser is false', () => {
-      const result = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue: new Set(['ws-other-id']),
-        watch: true,
-        isTriggeredByConnectedUser: false,
-      });
-
-      expect(result).toBe(true);
-    });
-
-    it('should return true when watch is true and it is triggered by the connected_user, but queueId is not in queue', () => {
-      const stateUpdateQueue = new Set(['ws-other-id-1', 'ws-other-id-2']);
-
-      const result = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue: stateUpdateQueue,
-        watch: true,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(stateUpdateQueue).toContain('ws-test-id');
-      expect(result).toBe(true);
-    });
-
-    it('should return false and remove queueId from queue when watch is true and WS initiated queueId is in queue', () => {
-      const stateUpdateQueue = new Set(['ws-test-id', 'ws-other-id']);
-
-      const result = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue,
-        watch: true,
-        fromWs: false,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(result).toBe(false);
-      expect(stateUpdateQueue).toEqual(new Set(['ws-other-id']));
-    });
-
-    it('should return false and remove queueId from queue when watch is true and HTTP initiated queueId is in queue', () => {
-      const stateUpdateQueue = new Set(['http-test-id', 'http-other-id']);
-
-      const result = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue,
-        watch: true,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(result).toBe(false);
-      expect(stateUpdateQueue).toEqual(new Set(['http-other-id']));
-    });
-
-    it('should handle empty queue when conditions are met', () => {
-      const result = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue: new Set(),
-        watch: true,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(result).toBe(true);
-    });
-
-    it('should not clear the queue state if 2 equal HTTP response updates arrive', () => {
-      const stateUpdateQueue = new Set<string>();
-
-      const result1 = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue,
-        watch: true,
-        fromWs: false,
-        isTriggeredByConnectedUser: true,
-      });
-
-      const result2 = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue,
-        watch: true,
-        fromWs: false,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(result1).toBe(true);
-      expect(result2).toBe(true);
-      expect(stateUpdateQueue).toEqual(new Set(['http-test-id']))
-    })
-
-    it('should not clear the queue state if 2 equal WS event updates arrive', () => {
-      const stateUpdateQueue = new Set<string>();
-
-      const result1 = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue,
-        watch: true,
-        isTriggeredByConnectedUser: true,
-      });
-
-      const result2 = shouldUpdateState({
-        stateUpdateQueueId: 'test-id',
-        stateUpdateQueue,
-        watch: true,
-        isTriggeredByConnectedUser: true,
-      });
-
-      expect(result1).toBe(true);
-      expect(result2).toBe(true);
-      expect(stateUpdateQueue).toEqual(new Set(['ws-test-id']))
-    })
-  });
-});

package/src/utils/unique-array-merge.test.ts

@@ -1,179 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { uniqueArrayMerge } from './unique-array-merge';
-
-describe('utils', () => {
-  describe(uniqueArrayMerge.name, () => {
-    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);
-    });
-  });
-});