@stream-io/feeds-client 0.1.0

package/src/state-updates/bookmark-utils.test.ts

@@ -0,0 +1,383 @@
+import { describe, it, expect } from 'vitest';
+import {
+  BookmarkAddedEvent,
+  BookmarkDeletedEvent,
+  BookmarkUpdatedEvent,
+  ActivityResponse,
+  BookmarkResponse,
+  UserResponse,
+} from '../gen/models';
+import {
+  addBookmarkToActivity,
+  removeBookmarkFromActivity,
+  updateBookmarkInActivity,
+  addBookmarkToActivities,
+  removeBookmarkFromActivities,
+  updateBookmarkInActivities,
+} from './bookmark-utils';
+
+const createMockUser = (id: string): UserResponse => ({
+  id,
+  created_at: new Date(),
+  updated_at: new Date(),
+  banned: false,
+  language: 'en',
+  online: false,
+  role: 'user',
+  blocked_user_ids: [],
+  teams: [],
+  custom: {},
+});
+
+const createMockActivity = (id: string): ActivityResponse => ({
+  id,
+  type: 'test',
+  created_at: new Date(),
+  updated_at: new Date(),
+  visibility: 'public',
+  bookmark_count: 0,
+  comment_count: 0,
+  share_count: 0,
+  attachments: [],
+  comments: [],
+  feeds: [],
+  filter_tags: [],
+  interest_tags: [],
+  latest_reactions: [],
+  mentioned_users: [],
+  own_bookmarks: [],
+  own_reactions: [],
+  custom: {},
+  reaction_groups: {},
+  search_data: {},
+  popularity: 0,
+  score: 0,
+  user: createMockUser('user1'),
+});
+
+const createMockBookmark = (
+  user: UserResponse,
+  activity: ActivityResponse,
+): BookmarkResponse => ({
+  created_at: new Date(),
+  updated_at: new Date(),
+  activity,
+  user,
+  custom: {},
+});
+
+const createMockAddedEvent = (
+  bookmark: BookmarkResponse,
+): BookmarkAddedEvent => ({
+  bookmark,
+  created_at: new Date(),
+  custom: {},
+  type: 'bookmark.added',
+});
+
+const createMockDeletedEvent = (
+  bookmark: BookmarkResponse,
+): BookmarkDeletedEvent => ({
+  bookmark,
+  created_at: new Date(),
+  custom: {},
+  type: 'bookmark.deleted',
+});
+
+const createMockUpdatedEvent = (
+  bookmark: BookmarkResponse,
+): BookmarkUpdatedEvent => ({
+  bookmark,
+  created_at: new Date(),
+  custom: {},
+  type: 'bookmark.updated',
+});
+
+describe('bookmark-utils', () => {
+  describe('addBookmarkToActivity', () => {
+    it('should add bookmark to own_bookmarks when from current user', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity);
+      const event = createMockAddedEvent(bookmark);
+
+      const result = addBookmarkToActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmark);
+    });
+
+    it('should not add bookmark to own_bookmarks when not from current user', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user2');
+      const bookmark = createMockBookmark(user, activity);
+      const event = createMockAddedEvent(bookmark);
+
+      const result = addBookmarkToActivity(event, activity, false);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(0);
+    });
+
+    it('should handle existing bookmarks correctly', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const existingBookmark = createMockBookmark(user, activity);
+      activity.own_bookmarks = [existingBookmark];
+
+      const newBookmark = createMockBookmark(user, activity);
+      const event = createMockAddedEvent(newBookmark);
+
+      const result = addBookmarkToActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(2);
+      expect(result.own_bookmarks).toContain(existingBookmark);
+      expect(result.own_bookmarks).toContain(newBookmark);
+    });
+  });
+
+  describe('removeBookmarkFromActivity', () => {
+    it('should remove bookmark from own_bookmarks when from current user', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity);
+      activity.own_bookmarks = [bookmark];
+
+      const event = createMockDeletedEvent(bookmark);
+      const result = removeBookmarkFromActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(0);
+    });
+
+    it('should not remove bookmark from own_bookmarks when not from current user', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity);
+      activity.own_bookmarks = [bookmark];
+
+      const event = createMockDeletedEvent(bookmark);
+      const result = removeBookmarkFromActivity(event, activity, false);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmark);
+    });
+
+    it('should remove correct bookmark when multiple bookmarks exist', () => {
+      const activity = createMockActivity('activity1');
+      const user1 = createMockUser('user1');
+      const user2 = createMockUser('user2');
+      const bookmark1 = createMockBookmark(user1, activity);
+      const bookmark2 = createMockBookmark(user2, activity);
+      activity.own_bookmarks = [bookmark1, bookmark2];
+
+      const event = createMockDeletedEvent(bookmark1);
+      const result = removeBookmarkFromActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmark2);
+    });
+  });
+
+  describe('updateBookmarkInActivity', () => {
+    it('should update bookmark in own_bookmarks when from current user', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity);
+      activity.own_bookmarks = [bookmark];
+
+      const updatedBookmark = {
+        ...bookmark,
+        custom: { updated: true },
+      };
+      const event = createMockUpdatedEvent(updatedBookmark);
+      const result = updateBookmarkInActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(updatedBookmark);
+    });
+
+    it('should not update bookmark in own_bookmarks when not from current user', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity);
+      activity.own_bookmarks = [bookmark];
+
+      const updatedBookmark = {
+        ...bookmark,
+        custom: { updated: true },
+      };
+      const event = createMockUpdatedEvent(updatedBookmark);
+      const result = updateBookmarkInActivity(event, activity, false);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmark); // unchanged
+    });
+
+    it('should not update bookmark if it does not exist', () => {
+      const activity = createMockActivity('activity1');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity);
+      activity.own_bookmarks = [bookmark];
+
+      const differentUser = createMockUser('user2');
+      const differentBookmark = createMockBookmark(differentUser, activity);
+      const event = createMockUpdatedEvent(differentBookmark);
+      const result = updateBookmarkInActivity(event, activity, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.own_bookmarks).toHaveLength(1);
+      expect(result.own_bookmarks[0]).toEqual(bookmark); // unchanged
+    });
+  });
+
+  describe('addBookmarkToActivities', () => {
+    it('should add bookmark to correct activity', () => {
+      const activity1 = createMockActivity('activity1');
+      const activity2 = createMockActivity('activity2');
+      const activities = [activity1, activity2];
+
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity1);
+      const event = createMockAddedEvent(bookmark);
+
+      const result = addBookmarkToActivities(event, activities, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.activities).toHaveLength(2);
+      expect(result.activities[0].own_bookmarks).toHaveLength(1);
+      expect(result.activities[0].own_bookmarks[0]).toEqual(bookmark);
+      expect(result.activities[1].own_bookmarks).toHaveLength(0);
+    });
+
+    it('should return unchanged when activity not found', () => {
+      const activity1 = createMockActivity('activity1');
+      const activities = [activity1];
+
+      const user = createMockUser('user1');
+      const differentActivity = createMockActivity('activity2');
+      const bookmark = createMockBookmark(user, differentActivity);
+      const event = createMockAddedEvent(bookmark);
+
+      const result = addBookmarkToActivities(event, activities, true);
+
+      expect(result.changed).toBe(false);
+      expect(result.activities).toEqual(activities);
+    });
+
+    it('should handle undefined activities', () => {
+      const user = createMockUser('user1');
+      const activity = createMockActivity('activity1');
+      const bookmark = createMockBookmark(user, activity);
+      const event = createMockAddedEvent(bookmark);
+
+      const result = addBookmarkToActivities(event, undefined, true);
+
+      expect(result.changed).toBe(false);
+      expect(result.activities).toEqual([]);
+    });
+  });
+
+  describe('removeBookmarkFromActivities', () => {
+    it('should remove bookmark from correct activity', () => {
+      const activity1 = createMockActivity('activity1');
+      const activity2 = createMockActivity('activity2');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity1);
+      activity1.own_bookmarks = [bookmark];
+      const activities = [activity1, activity2];
+
+      const event = createMockDeletedEvent(bookmark);
+      const result = removeBookmarkFromActivities(event, activities, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.activities).toHaveLength(2);
+      expect(result.activities[0].own_bookmarks).toHaveLength(0);
+      expect(result.activities[1].own_bookmarks).toHaveLength(0);
+    });
+
+    it('should return unchanged when activity not found', () => {
+      const activity1 = createMockActivity('activity1');
+      const activities = [activity1];
+
+      const user = createMockUser('user1');
+      const differentActivity = createMockActivity('activity2');
+      const bookmark = createMockBookmark(user, differentActivity);
+      const event = createMockDeletedEvent(bookmark);
+
+      const result = removeBookmarkFromActivities(event, activities, true);
+
+      expect(result.changed).toBe(false);
+      expect(result.activities).toEqual(activities);
+    });
+
+    it('should handle undefined activities', () => {
+      const user = createMockUser('user1');
+      const activity = createMockActivity('activity1');
+      const bookmark = createMockBookmark(user, activity);
+      const event = createMockDeletedEvent(bookmark);
+
+      const result = removeBookmarkFromActivities(event, undefined, true);
+
+      expect(result.changed).toBe(false);
+      expect(result.activities).toEqual([]);
+    });
+  });
+
+  describe('updateBookmarkInActivities', () => {
+    it('should update bookmark in correct activity', () => {
+      const activity1 = createMockActivity('activity1');
+      const activity2 = createMockActivity('activity2');
+      const user = createMockUser('user1');
+      const bookmark = createMockBookmark(user, activity1);
+      activity1.own_bookmarks = [bookmark];
+      const activities = [activity1, activity2];
+
+      const updatedBookmark = {
+        ...bookmark,
+        custom: { updated: true },
+      };
+      const event = createMockUpdatedEvent(updatedBookmark);
+      const result = updateBookmarkInActivities(event, activities, true);
+
+      expect(result.changed).toBe(true);
+      expect(result.activities).toHaveLength(2);
+      expect(result.activities[0].own_bookmarks).toHaveLength(1);
+      expect(result.activities[0].own_bookmarks[0]).toEqual(updatedBookmark);
+      expect(result.activities[1].own_bookmarks).toHaveLength(0);
+    });
+
+    it('should return unchanged when activity not found', () => {
+      const activity1 = createMockActivity('activity1');
+      const activities = [activity1];
+
+      const user = createMockUser('user1');
+      const differentActivity = createMockActivity('activity2');
+      const bookmark = createMockBookmark(user, differentActivity);
+      const event = createMockUpdatedEvent(bookmark);
+
+      const result = updateBookmarkInActivities(event, activities, true);
+
+      expect(result.changed).toBe(false);
+      expect(result.activities).toEqual(activities);
+    });
+
+    it('should handle undefined activities', () => {
+      const user = createMockUser('user1');
+      const activity = createMockActivity('activity1');
+      const bookmark = createMockBookmark(user, activity);
+      const event = createMockUpdatedEvent(bookmark);
+
+      const result = updateBookmarkInActivities(event, undefined, true);
+
+      expect(result.changed).toBe(false);
+      expect(result.activities).toEqual([]);
+    });
+  });
+});

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

@@ -0,0 +1,157 @@
+import {
+  BookmarkAddedEvent,
+  BookmarkDeletedEvent,
+  BookmarkUpdatedEvent,
+  ActivityResponse,
+} from '../gen/models';
+import { UpdateStateResult } from '../types-internal';
+
+const updateActivityInActivities = (
+  updatedActivity: ActivityResponse,
+  activities: ActivityResponse[],
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  const index = activities.findIndex((a) => a.id === updatedActivity.id);
+  if (index !== -1) {
+    const newActivities = [...activities];
+    newActivities[index] = updatedActivity;
+    return { changed: true, activities: newActivities };
+  } else {
+    return { changed: false, activities };
+  }
+};
+
+export const addBookmarkToActivity = (
+  event: BookmarkAddedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_bookmarks if the bookmark is from the current user
+  const ownBookmarks = [...(activity.own_bookmarks || [])];
+  if (isCurrentUser) {
+    ownBookmarks.push(event.bookmark);
+  }
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+export const removeBookmarkFromActivity = (
+  event: BookmarkDeletedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_bookmarks if the bookmark is from the current user
+  const ownBookmarks = isCurrentUser
+    ? (activity.own_bookmarks || []).filter(
+        (bookmark) =>
+          bookmark.user.id !== event.bookmark.user.id ||
+          bookmark.activity.id !== event.bookmark.activity.id,
+      )
+    : activity.own_bookmarks;
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+export const updateBookmarkInActivity = (
+  event: BookmarkUpdatedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_bookmarks if the bookmark is from the current user
+  let ownBookmarks = activity.own_bookmarks || [];
+  if (isCurrentUser) {
+    const bookmarkIndex = ownBookmarks.findIndex(
+      (bookmark) =>
+        bookmark.user.id === event.bookmark.user.id &&
+        bookmark.activity.id === event.bookmark.activity.id,
+    );
+    if (bookmarkIndex !== -1) {
+      ownBookmarks = [...ownBookmarks];
+      ownBookmarks[bookmarkIndex] = event.bookmark;
+    }
+  }
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+export const addBookmarkToActivities = (
+  event: BookmarkAddedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex(
+    (a) => a.id === event.bookmark.activity.id,
+  );
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = addBookmarkToActivity(event, activity, isCurrentUser);
+  return updateActivityInActivities(updatedActivity, activities);
+};
+
+export const removeBookmarkFromActivities = (
+  event: BookmarkDeletedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex(
+    (a) => a.id === event.bookmark.activity.id,
+  );
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = removeBookmarkFromActivity(
+    event,
+    activity,
+    isCurrentUser,
+  );
+  return updateActivityInActivities(updatedActivity, activities);
+};
+
+export const updateBookmarkInActivities = (
+  event: BookmarkUpdatedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex(
+    (a) => a.id === event.bookmark.activity.id,
+  );
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = updateBookmarkInActivity(
+    event,
+    activity,
+    isCurrentUser,
+  );
+  return updateActivityInActivities(updatedActivity, activities);
+};

package/src/types-internal.ts

@@ -0,0 +1,5 @@
+export type UpdateStateResult<T> = T & {
+  changed: boolean;
+};
+
+export type FromArray<T> = T extends Array<infer L> ? L : never;

package/src/types.ts

@@ -0,0 +1,20 @@
+import { ConnectionChangedEvent } from './common/real-time/event-models';
+import { NetworkChangedEvent } from './common/types';
+import { PagerResponse, WSEvent } from './gen/models';
+import { FeedsClient } from './FeedsClient';
+
+export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent;
+export type ActivityIdOrCommentId = string;
+
+export type GetCommentsRequest = Parameters<FeedsClient['getComments']>[0];
+
+export type GetCommentsRepliesRequest = Parameters<
+  FeedsClient['getCommentReplies']
+>[0];
+
+export type PagerResponseWithLoadingStates = PagerResponse & LoadingStates;
+
+export type LoadingStates = {
+  loading_next_page?: boolean;
+  loading_prev_page?: boolean;
+};

package/src/utils.ts

@@ -0,0 +1,4 @@
+export const isImageFile = (file: File) => {
+  // photoshop files begin with 'image/'
+  return file.type.startsWith('image/') && !file.type.endsWith('.photoshop');
+};