@stream-io/feeds-client 0.2.17 → 0.2.19

package/src/feed/event-handlers/activity/activity-utils.test.ts

@@ -1,252 +0,0 @@
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import type { ActivityResponse } from '../../../gen/models';
-import { FeedsClient } from '../../../feeds-client';
-import {
-  addActivitiesToState as addActivitiesToStateOriginal,
-  updateActivityInState,
-  removeActivityFromState as removeActivityFromStateOriginal,
-} from './';
-import {
-  generateActivityResponse,
-  generateFeedReactionResponse,
-} from '../../../test-utils';
-
-describe('activity-utils', () => {
-  let addActivitiesToState: OmitThisParameter<
-    typeof addActivitiesToStateOriginal
-  >;
-  let removeActivityFromState: OmitThisParameter<
-    typeof removeActivityFromStateOriginal
-  >;
-  let prehydrateActivities: (
-    newActivities: ActivityResponse[],
-  ) => ActivityResponse[];
-
-  beforeEach(() => {
-    const client = new FeedsClient('mock-api-key');
-    const feed = client.feed('some', 'feed');
-
-    addActivitiesToState = addActivitiesToStateOriginal.bind(feed);
-    removeActivityFromState = removeActivityFromStateOriginal.bind(feed);
-
-    prehydrateActivities = (newActivities: ActivityResponse[]) => {
-      const existingActivities = [...newActivities];
-
-      feed.state.partialNext({ activities: existingActivities });
-
-      return existingActivities;
-    };
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  describe('addActivitiesToState', () => {
-    const activity1 = generateActivityResponse({ id: 'activity1' });
-    const activity2 = generateActivityResponse({ id: 'activity2' });
-
-    it('should add activities to empty state', () => {
-      const result = addActivitiesToState([activity1], undefined, 'start');
-
-      expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].id).toBe('activity1');
-    });
-
-    it('should add activities to the start of existing activities', () => {
-      const existingActivities = prehydrateActivities([activity2]);
-      const result = addActivitiesToState(
-        [activity1],
-        existingActivities,
-        'start',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(2);
-      expect(result.activities[0].id).toBe('activity1');
-      expect(result.activities[1].id).toBe('activity2');
-    });
-
-    it('should add activities to the end of existing activities', () => {
-      const existingActivities = prehydrateActivities([activity1]);
-      const result = addActivitiesToState(
-        [activity2],
-        existingActivities,
-        'end',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(2);
-      expect(result.activities[0].id).toBe('activity1');
-      expect(result.activities[1].id).toBe('activity2');
-    });
-
-    it('should not add duplicate activities', () => {
-      const existingActivities = prehydrateActivities([activity1]);
-      const result = addActivitiesToState(
-        [activity1],
-        existingActivities,
-        'start',
-      );
-
-      expect(result.changed).toBe(false);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].id).toBe('activity1');
-    });
-
-    it('should handle multiple new activities correctly', () => {
-      const activity3 = generateActivityResponse({ id: 'activity3' });
-
-      const existingActivities = prehydrateActivities([activity1]);
-      const result = addActivitiesToState(
-        [activity2, activity3],
-        existingActivities,
-        'start',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(3);
-      expect(result.activities[0].id).toBe('activity2');
-      expect(result.activities[1].id).toBe('activity3');
-      expect(result.activities[2].id).toBe('activity1');
-    });
-  });
-
-  describe('updateActivityInState', () => {
-    it('should update an activity in the state', () => {
-      const originalActivity = generateActivityResponse({
-        id: 'activity1',
-        text: 'original text',
-      });
-      const updatedActivity = { ...originalActivity, text: 'updated text' };
-      const originalActivities = [originalActivity];
-
-      const result = updateActivityInState(
-        {
-          activity: updatedActivity,
-          created_at: new Date(),
-          fid: '',
-          type: '',
-          custom: {},
-        },
-        originalActivities,
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.entities).toHaveLength(1);
-      expect(result.entities![0].id).toBe('activity1');
-      expect(result.entities![0].text).toBe('updated text');
-
-      // Make sure we create a new array
-      expect(originalActivities === result.entities).toBe(false);
-    });
-
-    it('should preserve reaction data (own_reaction) when updating an activity', () => {
-      const r = generateFeedReactionResponse({
-        activity_id: 'activity1',
-        user: {
-          id: 'user1',
-        },
-      });
-      const originalActivity = generateActivityResponse({
-        id: 'activity1',
-        text: 'original text',
-        own_reactions: [r],
-        latest_reactions: [r],
-      });
-
-      const updatedActivity = generateActivityResponse({
-        id: 'activity1',
-        text: 'updated text',
-        own_reactions: [],
-        latest_reactions: [
-          r,
-          generateFeedReactionResponse({
-            activity_id: 'activity1',
-            user: { id: 'user2' },
-          }),
-        ],
-      });
-
-      const result = updateActivityInState(
-        {
-          activity: updatedActivity,
-          created_at: new Date(),
-          fid: '',
-          type: '',
-          custom: {},
-        },
-        [originalActivity],
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.entities![0].text).toBe('updated text');
-      // Check that reactions were preserved
-      expect(result.entities![0].own_reactions).toEqual(
-        originalActivity.own_reactions,
-      );
-    });
-
-    it('should return unchanged state if activity not found', () => {
-      const existingActivity = generateActivityResponse({ id: 'activity1' });
-      const updatedActivity = generateActivityResponse({
-        id: 'activity2',
-        text: 'some text',
-      });
-
-      const result = updateActivityInState(
-        {
-          activity: updatedActivity,
-          created_at: new Date(),
-          fid: '',
-          type: '',
-          custom: {},
-        },
-        [existingActivity],
-      );
-
-      expect(result.changed).toBe(false);
-      expect(result.entities).toHaveLength(1);
-      expect(result.entities![0].id).toBe('activity1');
-    });
-  });
-
-  describe('removeActivityFromState', () => {
-    it('should remove an activity from the state', () => {
-      const activity1 = generateActivityResponse({ id: 'activity1' });
-      const activity2 = generateActivityResponse({ id: 'activity2' });
-      const activities = prehydrateActivities([activity1, activity2]);
-
-      const result = removeActivityFromState(activity1, activities);
-
-      expect(result.changed).toBe(true);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities![0].id).toBe('activity2');
-      // Make sure we create a new array
-      expect(activities === result.activities).toBe(false);
-    });
-
-    it('should return unchanged state if activity not found', () => {
-      const activity1 = generateActivityResponse({ id: 'activity1' });
-      const activity2 = generateActivityResponse({ id: 'activity2' });
-      const activities = prehydrateActivities([activity1]);
-
-      const result = removeActivityFromState(activity2, activities);
-
-      expect(result.changed).toBe(false);
-      expect(result.activities).toHaveLength(1);
-      expect(result.activities![0].id).toBe('activity1');
-    });
-
-    it('should handle empty activities array', () => {
-      const activity = generateActivityResponse({ id: 'activity1' });
-      const activities: ActivityResponse[] = [];
-
-      const result = removeActivityFromState(activity, activities);
-
-      expect(result.changed).toBe(false);
-      expect(result.activities).toHaveLength(0);
-    });
-  });
-});

package/src/feed/event-handlers/activity/handle-activity-added.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { Feed } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import { handleActivityAdded } from './handle-activity-added';
-import {
-  generateActivityAddedEvent,
-  generateActivityResponse,
-  generateFeedResponse,
-  generateOwnUser,
-  getHumanId,
-} from '../../../test-utils';
-
-describe(handleActivityAdded.name, () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let currentUserId: string;
-
-  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,
-    );
-  });
-
-  it('initializes activities when state is empty and adds new activity to the start', () => {
-    const event = generateActivityAddedEvent();
-
-    const stateBefore = feed.currentState;
-    expect(stateBefore.activities).toBeUndefined();
-
-    const hydrateSpy = vi.spyOn(client, 'hydratePollCache');
-
-    handleActivityAdded.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.activities).toBeDefined();
-    expect(stateAfter.activities).toHaveLength(1);
-    expect(stateAfter.activities?.[0]).toBe(event.activity);
-    expect(hydrateSpy).toHaveBeenCalledWith([event.activity]);
-  });
-
-  it('prepends new activity when activities already exist', () => {
-    const existing = generateActivityResponse();
-    feed.state.partialNext({ activities: [existing] });
-
-    const event = generateActivityAddedEvent();
-
-    handleActivityAdded.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.activities).toHaveLength(2);
-    expect(stateAfter.activities?.[0]).toBe(event.activity);
-    expect(stateAfter.activities?.[1]).toBe(existing);
-  });
-
-  it('does not duplicate if activity already exists', () => {
-    const existing = generateActivityResponse();
-    feed.state.partialNext({ activities: [existing] });
-
-    const event = generateActivityAddedEvent({
-      activity: { id: existing.id },
-    });
-
-    const stateBefore = feed.currentState;
-    handleActivityAdded.call(feed, event);
-    const stateAfter = feed.currentState;
-
-    expect(stateAfter).toBe(stateBefore);
-    expect(stateAfter.activities).toHaveLength(1);
-    expect(stateAfter.activities?.[0]).toBe(existing);
-  });
-});

package/src/feed/event-handlers/activity/handle-activity-deleted.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { Feed } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import { handleActivityDeleted } from './handle-activity-deleted';
-import {
-  generateActivityDeletedEvent,
-  generateActivityPinResponse,
-  generateActivityResponse,
-  generateFeedResponse,
-  generateOwnUser,
-  getHumanId,
-} from '../../../test-utils/response-generators';
-
-describe(handleActivityDeleted.name, () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let currentUserId: string;
-
-  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,
-    );
-  });
-
-  it('removes the activity from activities array when present', () => {
-    const activity1 = generateActivityResponse();
-    const activity2 = generateActivityResponse();
-    feed.state.partialNext({ activities: [activity1, activity2] });
-
-    const event = generateActivityDeletedEvent({
-      activity: { id: activity1.id },
-    });
-
-    const stateBefore = feed.currentState;
-    expect(stateBefore.activities).toHaveLength(2);
-
-    handleActivityDeleted.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.activities).toHaveLength(1);
-    expect(stateAfter.activities?.[0].id).toBe(activity2.id);
-  });
-
-  it('removes the activity from pinned_activities when present', () => {
-    const pin1 = generateActivityPinResponse();
-    const pin2 = generateActivityPinResponse();
-    feed.state.partialNext({ pinned_activities: [pin1, pin2] });
-
-    const event = generateActivityDeletedEvent({
-      activity: { id: pin1.activity.id },
-    });
-
-    const stateBefore = feed.currentState;
-    expect(stateBefore.pinned_activities).toHaveLength(2);
-
-    handleActivityDeleted.call(feed, event);
-
-    const stateAfter = feed.currentState;
-
-    expect(stateAfter.pinned_activities).toHaveLength(1);
-    expect(stateAfter.pinned_activities?.[0]).toBe(pin2);
-  });
-
-  it('updates both arrays when the activity exists in both activities and pinned_activities', () => {
-    const sharedId = getHumanId();
-    const activity = generateActivityResponse({ id: sharedId });
-    const pinnedActivity = generateActivityPinResponse({
-      activity: { id: sharedId },
-    });
-    feed.state.partialNext({
-      activities: [activity],
-      pinned_activities: [pinnedActivity],
-    });
-
-    const event = generateActivityDeletedEvent({
-      activity: { id: sharedId },
-    });
-
-    handleActivityDeleted.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.activities).toHaveLength(0);
-    expect(stateAfter.pinned_activities).toHaveLength(0);
-  });
-
-  it('does nothing if the activity is not found in either list', () => {
-    const activity = generateActivityResponse();
-    const pinnedActivity = generateActivityPinResponse();
-    feed.state.partialNext({
-      activities: [activity],
-      pinned_activities: [pinnedActivity],
-    });
-
-    const event = generateActivityDeletedEvent({ activity: { id: 'unknown' } });
-
-    const stateBefore = feed.currentState;
-    handleActivityDeleted.call(feed, event);
-    const stateAfter = feed.currentState;
-
-    expect(stateAfter).toBe(stateBefore);
-  });
-});

package/src/feed/event-handlers/activity/handle-activity-pinned.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-
-import { Feed } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import { handleActivityPinned } from './handle-activity-pinned';
-import {
-  generateActivityPinnedEvent,
-  generateActivityPinResponse,
-  generateFeedResponse,
-} from '../../../test-utils/response-generators';
-import type { ActivityPinResponse } from '../../../gen/models';
-
-describe(handleActivityPinned.name, () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let pinnedActivity: ActivityPinResponse;
-  let otherPinnedActivity: ActivityPinResponse;
-
-  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,
-    );
-    pinnedActivity = generateActivityPinResponse();
-    otherPinnedActivity = generateActivityPinResponse();
-    feed.state.next((currentState) => ({
-      ...currentState,
-      pinned_activities: [otherPinnedActivity],
-    }));
-  });
-
-  it('adds a new activity to pinned_activities', () => {
-    const event = generateActivityPinnedEvent({
-      pinned_activity: pinnedActivity,
-    });
-    handleActivityPinned.call(feed, event);
-    const { pinned_activities } = feed.currentState;
-    expect(pinned_activities).toHaveLength(2);
-    expect(pinned_activities![0].activity.id).toBe(pinnedActivity.activity.id);
-    expect(pinned_activities![1]).toBe(otherPinnedActivity);
-  });
-
-  it('creates pinned_activities if it was undefined', () => {
-    feed.state.next((currentState) => ({
-      ...currentState,
-      pinned_activities: undefined,
-    }));
-    const event = generateActivityPinnedEvent({
-      pinned_activity: pinnedActivity,
-    });
-    handleActivityPinned.call(feed, event);
-    const { pinned_activities } = feed.currentState;
-    expect(pinned_activities).toHaveLength(1);
-    expect(pinned_activities![0].activity.id).toBe(pinnedActivity.activity.id);
-  });
-});