@stream-io/feeds-client 0.2.9 → 0.2.11

package/src/feed/event-handlers/comment/utils/update-comment-count.test.ts

@@ -0,0 +1,320 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+import { updateCommentCount as updateCommentCountInternal } from './update-comment-count';
+import * as commentHandlers from '../handle-comment-updated';
+import * as activityHandlers from '../../activity';
+import { FeedsClient } from '../../../../feeds-client';
+import { Feed } from '../../../feed';
+import { ActivityResponse, CommentResponse } from '../../../../gen/models';
+import {
+  generateCommentResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../../test-utils';
+
+vi.mock('../../activity', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../activity')>();
+  return {
+    ...actual,
+    handleActivityUpdated: vi.fn(),
+  };
+});
+
+vi.mock('../handle-comment-updated', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../handle-comment-updated')>();
+  return {
+    ...actual,
+    handleCommentUpdated: vi.fn(),
+  };
+});
+
+const handleCommentUpdated = commentHandlers.handleCommentUpdated as unknown as ReturnType<typeof vi.fn>;
+const handleActivityUpdated = activityHandlers.handleActivityUpdated as unknown as ReturnType<typeof vi.fn>;
+
+describe('updateCommentCount', () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: string;
+  let activityId: string;
+  let existingActivity: ActivityResponse;
+
+  let updateCommentCount: OmitThisParameter<typeof updateCommentCountInternal>;
+
+  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,
+    );
+    feed.state.partialNext({ watch: false });
+
+    updateCommentCount = updateCommentCountInternal.bind(feed);
+
+    activityId = `activity-${getHumanId()}`;
+    existingActivity = { id: activityId, comment_count: 0 } as ActivityResponse;
+
+    feed.state.partialNext({ activities: [existingActivity] });
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  })
+
+  it('correctly updates parent comment reply_count and comment_count (with watch: false)', () => {
+    const parentCommentId = 'c1';
+
+    const existingComment = generateCommentResponse({
+      id: parentCommentId,
+      object_id: activityId,
+      reply_count: 0,
+    });
+
+    feed.state.partialNext({
+      activities: [{ ...existingActivity, comment_count: 1 }],
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+        },
+      },
+    });
+
+    const incomingReply = generateCommentResponse({
+      id: 'c2',
+      object_id: activityId,
+      parent_id: parentCommentId,
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 11 },
+      comment: incomingReply,
+      replyCountUpdater: (prev: number) => prev + 1,
+    });
+
+    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
+    const [commentArg, secondArg] = handleCommentUpdated.mock.calls[0];
+    expect(secondArg).toBe(false);
+    expect(commentArg).toEqual({
+      comment: {
+        ...existingComment,
+        reply_count: 1,
+      },
+    });
+
+    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
+    expect(handleActivityUpdated).toHaveBeenCalledWith({
+      activity: { id: activityId, comment_count: 11 },
+    }, false);
+  });
+
+  it('updates parent comment reply_count when grandparent is missing (falls back to activity store)', () => {
+    const parentCommentId = 'c1';
+
+    const existingComment = generateCommentResponse({
+      id: parentCommentId,
+      object_id: activityId,
+      reply_count: 5,
+    });
+
+    feed.state.partialNext({
+      activities: [{ ...existingActivity, comment_count: 0 }],
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const incomingReply = generateCommentResponse({
+      id: 'c2',
+      object_id: activityId,
+      parent_id: parentCommentId,
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 1 },
+      comment: incomingReply,
+      replyCountUpdater: (prev: number) => prev - 2,
+    });
+
+    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
+    expect(handleCommentUpdated).toHaveBeenCalledWith(
+      { comment: { ...existingComment, reply_count: 3 } },
+      false,
+    );
+    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
+    expect(handleActivityUpdated).toHaveBeenCalledWith({
+      activity: { id: activityId, comment_count: 1 },
+    }, false);
+  });
+
+  it('updates the correct parent when replying to a depth-3 comment (entity_parent_id points to the parent comment store)', () => {
+    const c1: CommentResponse = generateCommentResponse({ id: 'c1', object_id: activityId, reply_count: 0 });
+    const c2: CommentResponse = generateCommentResponse({ id: 'c2', object_id: activityId, parent_id: 'c1', reply_count: 7 });
+
+    feed.state.partialNext({
+      activities: [{ ...existingActivity, comment_count: 1 }],
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [c1],
+        },
+        ['c1']: { entity_parent_id: activityId, comments: [c2] },
+        ['c2']: { entity_parent_id: 'c1', comments: [] },
+      },
+    });
+
+    const incomingReplyToC2: CommentResponse = generateCommentResponse({
+      id: 'c3',
+      object_id: activityId,
+      parent_id: 'c2',
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 1 },
+      comment: incomingReplyToC2,
+      replyCountUpdater: (prev: number) => prev + 5,
+    });
+
+    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
+    expect(handleCommentUpdated).toHaveBeenCalledWith(
+      { comment: { ...c2, reply_count: 12 } },
+      false,
+    );
+    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
+    expect(handleActivityUpdated).toHaveBeenCalledWith({
+      activity: { id: activityId, comment_count: 1 },
+    }, false);
+  });
+
+  it('does nothing on parent reply when parent comment is not found in the resolved store', () => {
+    feed.state.partialNext({
+      activities: [{ ...existingActivity, comment_count: 4 }],
+      comments_by_entity_id: {
+        [activityId]: { comments: [], },
+      },
+    });
+
+    const incomingReply: CommentResponse = generateCommentResponse({
+      id: 'child',
+      object_id: activityId,
+      parent_id: 'missing-parent',
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 5 },
+      comment: incomingReply,
+      replyCountUpdater: (prev: number) => prev + 1,
+    });
+
+    expect(handleCommentUpdated).not.toHaveBeenCalled();
+    // the activity still updates, as watch === true
+    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
+    expect(handleActivityUpdated).toHaveBeenCalledWith({
+      activity: { id: activityId, comment_count: 5 },
+    }, false);
+  });
+
+  it('skips parent reply update when comment has no parent_id (top-level comment)', () => {
+    feed.state.partialNext({
+      activities: [{ ...existingActivity, comment_count: 1 }],
+      comments_by_entity_id: {
+        [activityId]: { comments: [], },
+      },
+    });
+
+    const topLevel: CommentResponse = generateCommentResponse({
+      id: 'cTop',
+      object_id: activityId,
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 3 },
+      comment: topLevel,
+      replyCountUpdater: (prev: number) => prev + 100,
+    });
+
+    expect(handleCommentUpdated).not.toHaveBeenCalled();
+    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
+    expect(handleActivityUpdated).toHaveBeenCalledWith({
+      activity: { id: activityId, comment_count: 3 },
+    }, false);
+  });
+
+  it('no-ops any update if neither activity nor comment are found', () => {
+    feed.state.partialNext({
+      activities: [{ id: 'other-1', comment_count: 1 } as ActivityResponse, { id: 'other-2', comment_count: 3 } as ActivityResponse],
+      comments_by_entity_id: {},
+    });
+
+    const topLevel: CommentResponse = generateCommentResponse({
+      id: 'cTop',
+      object_id: 'missing-activity',
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 3 },
+      comment: topLevel,
+      replyCountUpdater: (prev: number) => prev + 1,
+    });
+
+    expect(handleActivityUpdated).not.toHaveBeenCalled();
+    expect(handleCommentUpdated).not.toHaveBeenCalled();
+  });
+
+  it('can update both parent reply_count and activity comment_count in the same call', () => {
+    const parentCommentId = 'c1';
+    const c1: CommentResponse = generateCommentResponse({ id: parentCommentId, object_id: activityId, reply_count: 10 });
+
+    feed.state.partialNext({
+      activities: [{ ...existingActivity, comment_count: 100 }],
+      comments_by_entity_id: {
+        [activityId]: { comments: [c1] },
+        [parentCommentId]: { entity_parent_id: activityId },
+      },
+    });
+
+    const incomingReply: CommentResponse = generateCommentResponse({
+      id: 'c2',
+      object_id: activityId,
+      parent_id: parentCommentId,
+      reply_count: 0,
+    });
+
+    updateCommentCount({
+      activity: { ...existingActivity, comment_count: 97 },
+      comment: incomingReply,
+      replyCountUpdater: (prev: number) => prev + 2,
+    });
+
+    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
+    expect(handleCommentUpdated).toHaveBeenCalledWith(
+      { comment: { ...c1, reply_count: 12 } },
+      false,
+    );
+    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
+    expect(handleActivityUpdated).toHaveBeenCalledWith({
+      activity: { id: activityId, comment_count: 97 },
+    }, false);
+  });
+});

package/src/feed/event-handlers/comment/utils/update-comment-count.ts

@@ -0,0 +1,51 @@
+import { ActivityResponse, Feed } from '@self';
+import { CommentResponse } from '@self';
+import { handleCommentUpdated } from '../handle-comment-updated';
+import { handleActivityUpdated } from '../../activity';
+
+export function updateCommentCount(
+  this: Feed,
+  {
+    activity,
+    comment,
+    replyCountUpdater,
+  }: {
+    activity: ActivityResponse;
+    comment: CommentResponse;
+    replyCountUpdater: (prevCount: number) => number;
+  },
+) {
+  const parentActivityId = comment.object_id;
+  // we update a comment if the new one is depth 2 or deeper
+  if (comment?.parent_id) {
+    // if the comment has a parent comment, we need to update the reply count on it
+    // if the parent has a parent comment as well, parent comment is stored in a list indexed by grandparent comment id
+    const grandparentCommentId =
+      this.currentState.comments_by_entity_id[comment?.parent_id ?? '']
+        ?.entity_parent_id;
+    // pick the grandparent of the comment we are trying to add so that we
+    // can update its state; if it doesn't exist the parent is an activity
+    const idToUpdate = grandparentCommentId ?? parentActivityId;
+    const commentToUpdate = this.currentState.comments_by_entity_id[
+      idToUpdate
+    ]?.comments?.find((c) => c.id === comment.parent_id);
+    if (commentToUpdate) {
+      handleCommentUpdated.bind(this)(
+        {
+          comment: {
+            ...commentToUpdate,
+            reply_count: replyCountUpdater(commentToUpdate.reply_count),
+          },
+        },
+        false,
+      );
+    }
+  }
+
+  // finally, update the activity comment_count if it exists
+  if (this.hasActivity(activity.id)) {
+    handleActivityUpdated.bind(this)({
+      activity,
+    }, false);
+  }
+}

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

@@ -74,7 +74,7 @@ export function handleFollowDeleted(
 
   if (
     !shouldUpdateState({
-      stateUpdateQueueId: getStateUpdateQueueId(follow, 'deleted'),
+      stateUpdateQueueId: getStateUpdateQueueId(follow, 'follow-deleted'),
       stateUpdateQueue: this.stateUpdateQueue,
       watch: this.currentState.watch,
       fromWs,

package/src/feed/feed.ts

@@ -34,7 +34,6 @@ import {
   handleFeedMemberAdded,
   handleFeedMemberRemoved,
   handleFeedMemberUpdated,
-  handleCommentReaction,
   handleBookmarkAdded,
   handleActivityDeleted,
   handleActivityRemovedFromFeed,
@@ -43,6 +42,8 @@ import {
   handleActivityMarked,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
+  handleCommentReactionAdded,
+  handleCommentReactionDeleted,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -167,8 +168,8 @@ export class Feed extends FeedApi {
     'feeds.follow.created': handleFollowCreated.bind(this),
     'feeds.follow.deleted': handleFollowDeleted.bind(this),
     'feeds.follow.updated': handleFollowUpdated.bind(this),
-    'feeds.comment.reaction.added': handleCommentReaction.bind(this),
-    'feeds.comment.reaction.deleted': handleCommentReaction.bind(this),
+    'feeds.comment.reaction.added': handleCommentReactionAdded.bind(this),
+    'feeds.comment.reaction.deleted': handleCommentReactionDeleted.bind(this),
     'feeds.comment.reaction.updated': Feed.noop,
     'feeds.feed_member.added': handleFeedMemberAdded.bind(this),
     'feeds.feed_member.removed': handleFeedMemberRemoved.bind(this),

package/src/feeds-client/feeds-client.ts

@@ -1,8 +1,14 @@
 import { FeedsApi } from '../gen/feeds/FeedsApi';
 import {
   ActivityResponse,
+  AddCommentReactionRequest,
+  AddCommentReactionResponse,
+  AddCommentRequest,
+  AddCommentResponse,
   AddReactionRequest,
   DeleteActivityReactionResponse,
+  DeleteCommentReactionResponse,
+  DeleteCommentResponse,
   FeedResponse,
   FileUploadRequest,
   FollowBatchRequest,
@@ -13,6 +19,10 @@ import {
   PollVotesResponse,
   QueryFeedsRequest,
   QueryPollVotesRequest,
+  UpdateActivityRequest,
+  UpdateActivityResponse,
+  UpdateCommentRequest,
+  UpdateCommentResponse,
   UpdateFollowRequest,
   UserRequest,
   WSEvent,
@@ -41,6 +51,12 @@ import {
   Feed,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
+  handleActivityUpdated,
+  handleCommentAdded,
+  handleCommentDeleted,
+  handleCommentReactionAdded,
+  handleCommentReactionDeleted,
+  handleCommentUpdated,
   handleFeedUpdated,
   handleFollowCreated,
   handleFollowDeleted,
@@ -53,6 +69,7 @@ import {
   SyncFailure,
   UnhandledErrorType,
 } from '../common/real-time/event-models';
+import { updateCommentCount } from '../feed/event-handlers/comment/utils';
 import { configureLoggers } from '../utils/logger';
 
 export type FeedsClientState = {
@@ -331,6 +348,72 @@ export class FeedsClient extends FeedsApi {
     });
   };
 
+  updateActivity = async (
+    request: UpdateActivityRequest & {
+      id: string;
+    },
+  ): Promise<StreamResponse<UpdateActivityResponse>> => {
+    const response = await super.updateActivity(request);
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleActivityUpdated.bind(feed)(response, false);
+    }
+    return response;
+  };
+
+  addComment = async (
+    request: AddCommentRequest,
+  ): Promise<StreamResponse<AddCommentResponse>> => {
+    const response = await super.addComment(request);
+    const { comment } = response;
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleCommentAdded.bind(feed)(response, false);
+      const parentActivityId = comment.object_id;
+      if (feed.hasActivity(parentActivityId)) {
+        const activityToUpdate = feed.currentState.activities?.find(
+          (activity) => activity.id === parentActivityId,
+        );
+        if (activityToUpdate) {
+          updateCommentCount.bind(feed)({
+            activity: {
+              ...activityToUpdate,
+              comment_count: activityToUpdate.comment_count + 1,
+            },
+            comment,
+            replyCountUpdater: (prevCount) => prevCount + 1,
+          });
+        }
+      }
+    }
+    return response;
+  };
+
+  updateComment = async (
+    request: UpdateCommentRequest & { id: string },
+  ): Promise<StreamResponse<UpdateCommentResponse>> => {
+    const response = await super.updateComment(request);
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleCommentUpdated.bind(feed)(response, false);
+    }
+    return response;
+  };
+
+  deleteComment = async (request: {
+    id: string;
+    hard_delete?: boolean;
+  }): Promise<StreamResponse<DeleteCommentResponse>> => {
+    const response = await super.deleteComment(request);
+    const { activity, comment } = response;
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleCommentDeleted.bind(feed)({ comment }, false);
+      updateCommentCount.bind(feed)({
+        activity,
+        comment,
+        replyCountUpdater: (prevCount) => prevCount - 1,
+      });
+    }
+    return response;
+  };
+
   addReaction = async (
     request: AddReactionRequest & {
       activity_id: string;
@@ -354,6 +437,27 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
+  addCommentReaction = async (
+    request: AddCommentReactionRequest & { id: string },
+  ): Promise<StreamResponse<AddCommentReactionResponse>> => {
+    const response = await super.addCommentReaction(request);
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleCommentReactionAdded.bind(feed)(response, false);
+    }
+    return response;
+  };
+
+  deleteCommentReaction = async (request: {
+    id: string;
+    type: string;
+  }): Promise<StreamResponse<DeleteCommentReactionResponse>> => {
+    const response = await super.deleteCommentReaction(request);
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleCommentReactionDeleted.bind(feed)(response, false);
+    }
+    return response;
+  };
+
   queryPollAnswers = async (
     request: QueryPollVotesRequest & { poll_id: string; user_id?: string },
   ): Promise<StreamResponse<PollVotesResponse>> => {

package/src/test-utils/response-generators.ts

@@ -11,7 +11,7 @@ import {
   OwnUser,
   OwnUserResponse,
   PinActivityResponse,
-  UserResponse,
+  UserResponse, UserResponseCommonFields,
 } from '../gen/models';
 import { humanId } from 'human-id';
 import { EventPayload } from '../types-internal';
@@ -35,6 +35,23 @@ export const generateUserResponse = (
   ...overrides,
 });
 
+export const generateUserResponseCommonFields = (
+  overrides: Partial<UserResponseCommonFields> = {},
+): UserResponseCommonFields => ({
+  id: `user-${getHumanId()}`,
+  name: humanId({ separator: ' ' }),
+  created_at: new Date(),
+  updated_at: new Date(),
+  banned: false,
+  language: 'en',
+  online: false,
+  role: 'user',
+  blocked_user_ids: [],
+  teams: [],
+  custom: {},
+  ...overrides,
+});
+
 export const generateOwnUserResponse = (
   overrides: Partial<OwnUserResponse> = {},
 ): OwnUserResponse => ({

package/src/types-internal.ts

@@ -11,10 +11,10 @@ export type EventPayload<T extends WSEvent['type']> = Extract<
   { type: T }
 >;
 
-export type PartializeAllBut<T, K extends keyof T> = Pick<T, K> & {
-  [key in K]?: T[key];
-};
+export type PartializeAllBut<T, K extends keyof T> = {
+  [P in K]-?: T[P];
+} & { [P in Exclude<keyof T, K>]?: T[P] };
 
 export type CommonProps<A, B> = {
-  [K in keyof A & keyof B]: A[K] & B[K]
+  [K in keyof A & keyof B]: A[K] & B[K];
 };

package/src/utils/ensure-exhausted.ts

@@ -0,0 +1,5 @@
+import { getLogger } from './logger';
+
+export const ensureExhausted = (x: never, message: string) => {
+  getLogger('helpers').warn(message, x);
+};

package/src/utils/event-triggered-by-connected-user.test.ts

@@ -0,0 +1,73 @@
+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/event-triggered-by-connected-user.ts

@@ -0,0 +1,15 @@
+import { Feed } from '../feed';
+import { UserResponseCommonFields } from '../gen/models';
+
+export function eventTriggeredByConnectedUser(
+  this: Feed,
+  payload: { user?: UserResponseCommonFields },
+) {
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+  const payloadUser = payload.user ?? connectedUser;
+
+  return (
+    typeof connectedUser !== 'undefined' &&
+    connectedUser?.id === payloadUser?.id
+  );
+}