@stream-io/feeds-client 0.1.9 → 0.1.11

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

@@ -0,0 +1,75 @@
+import type { Feed } from '../../../feed';
+import type {
+  ActivityReactionDeletedEvent,
+  ActivityResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from './handle-activity-updated';
+export const removeReactionFromActivity = (
+  event: ActivityReactionDeletedEvent,
+  activity: ActivityResponse,
+  isCurrentUser: boolean,
+): UpdateStateResult<ActivityResponse> => {
+  // Update own_reactions if the reaction is from the current user
+  const ownReactions = isCurrentUser
+    ? (activity.own_reactions || []).filter(
+        (r) =>
+          !(
+            r.type === event.reaction.type &&
+            r.user.id === event.reaction.user.id
+          ),
+      )
+    : activity.own_reactions;
+
+  return {
+    ...activity,
+    own_reactions: ownReactions,
+    latest_reactions: event.activity.latest_reactions,
+    reaction_groups: event.activity.reaction_groups,
+    changed: true,
+  };
+};
+
+export const removeReactionFromActivities = (
+  event: ActivityReactionDeletedEvent,
+  activities: ActivityResponse[] | undefined,
+  isCurrentUser: boolean,
+): UpdateStateResult<{ activities: ActivityResponse[] }> => {
+  if (!activities) {
+    return { changed: false, activities: [] };
+  }
+
+  const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
+  if (activityIndex === -1) {
+    return { changed: false, activities };
+  }
+
+  const activity = activities[activityIndex];
+  const updatedActivity = removeReactionFromActivity(
+    event,
+    activity,
+    isCurrentUser,
+  );
+  return updateActivityInState(updatedActivity, activities, true);
+};
+
+export function handleActivityReactionDeleted(
+  this: Feed,
+  event: EventPayload<'feeds.activity.reaction.deleted'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+  const isCurrentUser = Boolean(
+    connectedUser && event.reaction.user.id === connectedUser.id,
+  );
+
+  const result = removeReactionFromActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

package/src/feed/event-handlers/activity/handle-activity-removed-from-feed.ts

@@ -0,0 +1,16 @@
+import { Feed } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+import { removeActivityFromState } from './handle-activity-deleted';
+
+export function handleActivityRemovedFromFeed(
+  this: Feed,
+  event: EventPayload<'feeds.activity.removed_from_feed'>,
+) {
+  const currentActivities = this.currentState.activities;
+  if (currentActivities) {
+    const result = removeActivityFromState(event.activity, currentActivities);
+    if (result.changed) {
+      this.state.partialNext({ activities: result.activities });
+    }
+  }
+}

package/src/feed/event-handlers/activity/handle-activity-updated.ts

@@ -0,0 +1,47 @@
+import { Feed } from '../../../feed';
+import { ActivityResponse } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+
+export const updateActivityInState = (
+  updatedActivityResponse: ActivityResponse,
+  activities: ActivityResponse[],
+  replaceCompletely: boolean = false,
+) => {
+  const index = activities.findIndex(
+    (a) => a.id === updatedActivityResponse.id,
+  );
+  if (index !== -1) {
+    const newActivities = [...activities];
+    const activity = activities[index];
+
+    if (replaceCompletely) {
+      newActivities[index] = updatedActivityResponse;
+    } else {
+      newActivities[index] = {
+        ...updatedActivityResponse,
+        own_reactions: activity.own_reactions,
+        own_bookmarks: activity.own_bookmarks,
+        latest_reactions: activity.latest_reactions,
+        reaction_groups: activity.reaction_groups,
+      };
+    }
+
+    return { changed: true, activities: newActivities };
+  } else {
+    return { changed: false, activities };
+  }
+};
+
+export function handleActivityUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.activity.updated'>,
+) {
+  const currentActivities = this.currentState.activities;
+  if (currentActivities) {
+    const result = updateActivityInState(event.activity, currentActivities);
+    if (result.changed) {
+      this.client.hydratePollCache([event.activity]);
+      this.state.partialNext({ activities: result.activities });
+    }
+  }
+}

package/src/feed/event-handlers/activity/index.ts

@@ -0,0 +1,6 @@
+export * from './handle-activity-added';
+export * from './handle-activity-deleted';
+export * from './handle-activity-removed-from-feed';
+export * from './handle-activity-updated';
+export * from './handle-activity-reaction-added';
+export * from './handle-activity-reaction-deleted';

package/src/{state-updates → feed/event-handlers/bookmark}/bookmark-utils.test.ts

@@ -6,7 +6,7 @@ import {
   ActivityResponse,
   BookmarkResponse,
   UserResponse,
-} from '../gen/models';
+} from '../../../gen/models';
 import {
   addBookmarkToActivity,
   removeBookmarkFromActivity,
@@ -14,7 +14,7 @@ import {
   addBookmarkToActivities,
   removeBookmarkFromActivities,
   updateBookmarkInActivities,
-} from './bookmark-utils';
+} from './';
 
 const createMockUser = (id: string): UserResponse => ({
   id,

package/src/feed/event-handlers/bookmark/handle-bookmark-added.ts

@@ -0,0 +1,63 @@
+import type { Feed } from '../../../feed';
+import type { ActivityResponse, BookmarkAddedEvent } from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from '../activity';
+
+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 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 updateActivityInState(updatedActivity, activities, true);
+};
+
+export function handleBookmarkAdded(
+  this: Feed,
+  event: EventPayload<'feeds.bookmark.added'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+
+  const result = addBookmarkToActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

package/src/feed/event-handlers/bookmark/handle-bookmark-deleted.ts

@@ -0,0 +1,84 @@
+import type { Feed } from '../../../feed';
+import type {
+  ActivityResponse,
+  BookmarkDeletedEvent,
+  BookmarkResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from '../activity';
+
+// Helper function to check if two bookmarks are the same
+// A bookmark is identified by activity_id + folder_id + user_id
+export const isSameBookmark = (
+  bookmark1: BookmarkResponse,
+  bookmark2: BookmarkResponse,
+): boolean => {
+  return (
+    bookmark1.user.id === bookmark2.user.id &&
+    bookmark1.activity.id === bookmark2.activity.id &&
+    bookmark1.folder?.id === bookmark2.folder?.id
+  );
+};
+
+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 updateActivityInState(updatedActivity, activities, 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) => !isSameBookmark(bookmark, event.bookmark),
+      )
+    : activity.own_bookmarks;
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+export function handleBookmarkDeleted(
+  this: Feed,
+  event: EventPayload<'feeds.bookmark.deleted'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+
+  const result = removeBookmarkFromActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

package/src/feed/event-handlers/bookmark/handle-bookmark-updated.ts

@@ -0,0 +1,76 @@
+import type { Feed } from '../../../feed';
+import type {
+  ActivityResponse,
+  BookmarkUpdatedEvent,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+import { updateActivityInState } from '../activity';
+import { isSameBookmark } from './handle-bookmark-deleted';
+
+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) =>
+      isSameBookmark(bookmark, event.bookmark),
+    );
+    if (bookmarkIndex !== -1) {
+      ownBookmarks = [...ownBookmarks];
+      ownBookmarks[bookmarkIndex] = event.bookmark;
+    }
+  }
+
+  return {
+    ...activity,
+    own_bookmarks: ownBookmarks,
+    changed: true,
+  };
+};
+
+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 updateActivityInState(updatedActivity, activities, true);
+};
+
+export function handleBookmarkUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.bookmark.updated'>,
+) {
+  const currentActivities = this.currentState.activities;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+
+  const result = updateBookmarkInActivities(
+    event,
+    currentActivities,
+    isCurrentUser,
+  );
+  if (result.changed) {
+    this.state.partialNext({ activities: result.activities });
+  }
+}

package/src/feed/event-handlers/bookmark/index.ts

@@ -0,0 +1,3 @@
+export * from './handle-bookmark-added';
+export * from './handle-bookmark-deleted';
+export * from './handle-bookmark-updated';

package/src/feed/event-handlers/comment/handle-comment-added.ts

@@ -0,0 +1,38 @@
+import type { Feed } from '../../../feed';
+import type { EventPayload } from '../../../types-internal';
+
+export function handleCommentAdded(
+  this: Feed,
+  event: EventPayload<'feeds.comment.added'>,
+) {
+  const { comment } = event;
+  const entityId = comment.parent_id ?? comment.object_id;
+
+  this.state.next((currentState) => {
+    const entityState = currentState.comments_by_entity_id[entityId];
+
+    if (typeof entityState?.comments === 'undefined') {
+      return currentState;
+    }
+
+    const newComments = entityState?.comments ? [...entityState.comments] : [];
+
+    if (entityState.pagination?.sort === 'last') {
+      newComments.unshift(comment);
+    } else {
+      // 'first' and other sort options
+      newComments.push(comment);
+    }
+
+    return {
+      ...currentState,
+      comments_by_entity_id: {
+        ...currentState.comments_by_entity_id,
+        [entityId]: {
+          ...currentState.comments_by_entity_id[entityId],
+          comments: newComments,
+        },
+      },
+    };
+  });
+}

package/src/feed/event-handlers/comment/handle-comment-deleted.ts

@@ -0,0 +1,35 @@
+import { Feed } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+
+export function handleCommentDeleted(
+  this: Feed,
+  { comment }: EventPayload<'feeds.comment.deleted'>,
+) {
+  const entityId = comment.parent_id ?? comment.object_id;
+
+  this.state.next((currentState) => {
+    const newCommentsByEntityId = {
+      ...currentState.comments_by_entity_id,
+      [entityId]: {
+        ...currentState.comments_by_entity_id[entityId],
+      },
+    };
+
+    const index = this.getCommentIndex(comment, currentState);
+
+    if (newCommentsByEntityId?.[entityId]?.comments?.length && index !== -1) {
+      newCommentsByEntityId[entityId].comments = [
+        ...newCommentsByEntityId[entityId].comments,
+      ];
+
+      newCommentsByEntityId[entityId]?.comments?.splice(index, 1);
+    }
+
+    delete newCommentsByEntityId[comment.id];
+
+    return {
+      ...currentState,
+      comments_by_entity_id: newCommentsByEntityId,
+    };
+  });
+}

package/src/feed/event-handlers/comment/handle-comment-reaction.ts

@@ -0,0 +1,61 @@
+import { Feed } from '../../../feed';
+import { CommentResponse } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+
+export function handleCommentReaction(
+  this: Feed,
+  event: EventPayload<
+    'feeds.comment.reaction.added' | 'feeds.comment.reaction.deleted'
+  >,
+) {
+  const { comment, reaction } = event;
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+
+  this.state.next((currentState) => {
+    const forId = comment.parent_id ?? comment.object_id;
+    const entityState = currentState.comments_by_entity_id[forId];
+
+    const commentIndex = this.getCommentIndex(comment, currentState);
+
+    if (commentIndex === -1) return currentState;
+
+    const newComments = entityState?.comments?.concat([]) ?? [];
+
+    const commentCopy: Partial<CommentResponse> = { ...comment };
+
+    delete commentCopy.own_reactions;
+
+    const newComment: CommentResponse = {
+      ...newComments[commentIndex],
+      ...commentCopy,
+      // TODO: FIXME this should be handled by the backend
+      latest_reactions: commentCopy.latest_reactions ?? [],
+      reaction_groups: commentCopy.reaction_groups ?? {},
+    };
+
+    newComments[commentIndex] = newComment;
+
+    if (reaction.user.id === connectedUser?.id) {
+      if (event.type === 'feeds.comment.reaction.added') {
+        newComment.own_reactions = newComment.own_reactions.concat(
+          reaction,
+        ) ?? [reaction];
+      } else if (event.type === 'feeds.comment.reaction.deleted') {
+        newComment.own_reactions = newComment.own_reactions.filter(
+          (r) => r.type !== reaction.type,
+        );
+      }
+    }
+
+    return {
+      ...currentState,
+      comments_by_entity_id: {
+        ...currentState.comments_by_entity_id,
+        [forId]: {
+          ...entityState,
+          comments: newComments,
+        },
+      },
+    };
+  });
+}

package/src/feed/event-handlers/comment/handle-comment-updated.ts

@@ -0,0 +1,35 @@
+import { Feed } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+
+export function handleCommentUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.comment.updated'>,
+) {
+  const { comment } = event;
+  const entityId = comment.parent_id ?? comment.object_id;
+
+  this.state.next((currentState) => {
+    const entityState = currentState.comments_by_entity_id[entityId];
+
+    if (!entityState?.comments?.length) return currentState;
+
+    const index = this.getCommentIndex(comment, currentState);
+
+    if (index === -1) return currentState;
+
+    const newComments = [...entityState.comments];
+
+    newComments[index] = comment;
+
+    return {
+      ...currentState,
+      comments_by_entity_id: {
+        ...currentState.comments_by_entity_id,
+        [entityId]: {
+          ...currentState.comments_by_entity_id[entityId],
+          comments: newComments,
+        },
+      },
+    };
+  });
+}

package/src/feed/event-handlers/comment/index.ts

@@ -0,0 +1,4 @@
+export * from './handle-comment-added';
+export * from './handle-comment-deleted';
+export * from './handle-comment-updated';
+export * from './handle-comment-reaction';

package/src/feed/event-handlers/feed/handle-feed-updated.ts

@@ -0,0 +1,9 @@
+import { Feed } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+
+export function handleFeedUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.feed.updated'>,
+) {
+  this.state.partialNext({ ...event.feed });
+}

package/src/feed/event-handlers/feed/index.ts

@@ -0,0 +1 @@
+export * from './handle-feed-updated';

package/src/feed/event-handlers/feed-member/handle-feed-member-added.ts

@@ -0,0 +1,31 @@
+import { Feed, FeedState } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+
+export function handleFeedMemberAdded(
+  this: Feed,
+  event: EventPayload<'feeds.feed_member.added'>,
+) {
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+
+  this.state.next((currentState) => {
+    let newState: FeedState | undefined;
+
+    if (typeof currentState.members !== 'undefined') {
+      newState ??= {
+        ...currentState,
+      };
+
+      newState.members = [event.member, ...currentState.members];
+    }
+
+    if (connectedUser?.id === event.member.user.id) {
+      newState ??= {
+        ...currentState,
+      };
+
+      newState.own_membership = event.member;
+    }
+
+    return newState ?? currentState;
+  });
+}

package/src/feed/event-handlers/feed-member/handle-feed-member-removed.ts

@@ -0,0 +1,24 @@
+import { Feed } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+
+export function handleFeedMemberRemoved(
+  this: Feed,
+  event: EventPayload<'feeds.feed_member.removed'>,
+) {
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+
+  this.state.next((currentState) => {
+    const newState = {
+      ...currentState,
+      members: currentState.members?.filter(
+        (member) => member.user.id !== event.user?.id,
+      ),
+    };
+
+    if (connectedUser?.id === event.member_id) {
+      delete newState.own_membership;
+    }
+
+    return newState;
+  });
+}

package/src/feed/event-handlers/feed-member/handle-feed-member-updated.ts

@@ -0,0 +1,40 @@
+import { Feed, FeedState } from '../../../feed';
+import { EventPayload } from '../../../types-internal';
+
+export function handleFeedMemberUpdated(
+  this: Feed,
+  event: EventPayload<'feeds.feed_member.updated'>,
+) {
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+
+  this.state.next((currentState) => {
+    const memberIndex =
+      currentState.members?.findIndex(
+        (member) => member.user.id === event.member.user.id,
+      ) ?? -1;
+
+    let newState: FeedState | undefined;
+
+    if (memberIndex !== -1) {
+      // if there's an index, there's a member to update
+      const newMembers = [...currentState.members!];
+      newMembers[memberIndex] = event.member;
+
+      newState ??= {
+        ...currentState,
+      };
+
+      newState.members = newMembers;
+    }
+
+    if (connectedUser?.id === event.member.user.id) {
+      newState ??= {
+        ...currentState,
+      };
+
+      newState.own_membership = event.member;
+    }
+
+    return newState ?? currentState;
+  });
+}