@stream-io/feeds-client 0.2.2 → 0.2.3

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

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleFeedMemberAdded } from './handle-feed-member-added';
+import {
+  generateFeedResponse,
+  generateFeedMemberAddedEvent,
+  generateFeedMemberResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleFeedMemberAdded.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('prepends to members if members array exists', () => {
+    const existingMember = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [existingMember] });
+
+    const event = generateFeedMemberAddedEvent();
+
+    handleFeedMemberAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.members).toHaveLength(2);
+    expect(stateAfter.members?.[0]).toBe(event.member);
+  });
+
+  it('does not create members array if it does not exist', () => {
+    const event = generateFeedMemberAddedEvent();
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.members).toBeUndefined();
+
+    handleFeedMemberAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('sets own_membership when the added member is the connected user', () => {
+    const event = generateFeedMemberAddedEvent({
+      member: { user: { id: currentUserId } },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.own_membership).toBeUndefined();
+
+    handleFeedMemberAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.own_membership).toBe(event.member);
+  });
+});

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

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleFeedMemberRemoved } from './handle-feed-member-removed';
+import {
+  generateFeedResponse,
+  generateFeedMemberRemovedEvent,
+  generateFeedMemberResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleFeedMemberRemoved.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 from members if present', () => {
+    const memberToRemove = generateFeedMemberResponse();
+    const memberToKeep = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [memberToRemove, memberToKeep] });
+
+    const event = generateFeedMemberRemovedEvent({
+      member_id: memberToRemove.user.id,
+    });
+
+    handleFeedMemberRemoved.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.members).toHaveLength(1);
+    expect(stateAfter.members?.[0]).toBe(memberToKeep);
+  });
+
+  it('does not change state when members array is undefined', () => {
+    const event = generateFeedMemberRemovedEvent();
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.members).toBeUndefined();
+
+    handleFeedMemberRemoved.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('deletes own_membership when the removed member is the connected user', () => {
+    const ownMember = generateFeedMemberResponse({
+      user: { id: currentUserId },
+    });
+    feed.state.partialNext({ own_membership: ownMember, members: [] });
+
+    const event = generateFeedMemberRemovedEvent({ member_id: currentUserId });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.own_membership).toBe(ownMember);
+
+    handleFeedMemberRemoved.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.own_membership).toBeUndefined();
+    expect(stateAfter.members).toBe(stateBefore.members);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { Feed } from '../../../feed';
+import { Feed, FeedState } from '../../../feed';
 import { EventPayload } from '../../../types-internal';
 
 export function handleFeedMemberRemoved(
@@ -8,17 +8,27 @@ export function handleFeedMemberRemoved(
   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,
-      ),
-    };
+    let newState: FeedState | undefined;
 
-    if (connectedUser?.id === event.member_id) {
+    if (typeof currentState.members !== 'undefined') {
+      const filtered = currentState.members.filter(
+        (member) => member.user.id !== event.member_id,
+      );
+
+      if (filtered.length !== currentState.members.length) {
+        newState ??= { ...currentState };
+        newState.members = filtered;
+      }
+    }
+
+    if (
+      connectedUser?.id === event.member_id &&
+      typeof currentState.own_membership !== 'undefined'
+    ) {
+      newState ??= { ...currentState };
       delete newState.own_membership;
     }
 
-    return newState;
+    return newState ?? currentState;
   });
 }

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

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleFeedMemberUpdated } from './handle-feed-member-updated';
+import {
+  generateFeedResponse,
+  generateFeedMemberUpdatedEvent,
+  generateFeedMemberResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleFeedMemberUpdated.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('updates an existing member in members array', () => {
+    const member1 = generateFeedMemberResponse();
+    const member2 = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [member1, member2] });
+
+    const event = generateFeedMemberUpdatedEvent({
+      member: { user: { id: member1.user.id }, role: 'admin' },
+    });
+
+    handleFeedMemberUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.members).toHaveLength(2);
+    expect(stateAfter.members?.[0]).toBe(event.member);
+    expect(stateAfter.members?.[1]).toBe(member2);
+  });
+
+  it('does not modify members when target is not present', () => {
+    const existingMember = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [existingMember] });
+
+    const event = generateFeedMemberUpdatedEvent();
+
+    const stateBefore = feed.currentState;
+    handleFeedMemberUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('sets own_membership when the updated member is the connected user', () => {
+    const event = generateFeedMemberUpdatedEvent({
+      member: {
+        user: { id: currentUserId },
+        role: 'owner',
+        status: 'member',
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.own_membership).toBeUndefined();
+
+    handleFeedMemberUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.own_membership).toBe(event.member);
+  });
+});

package/src/gen/feeds/FeedsApi.ts

@@ -578,6 +578,7 @@ export class FeedsApi {
     const body = {
       type: request?.type,
       create_notification_activity: request?.create_notification_activity,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -888,6 +889,7 @@ export class FeedsApi {
       object_type: request?.object_type,
       create_notification_activity: request?.create_notification_activity,
       parent_id: request?.parent_id,
+      skip_push: request?.skip_push,
       attachments: request?.attachments,
       mentioned_user_ids: request?.mentioned_user_ids,
       custom: request?.custom,
@@ -1003,6 +1005,7 @@ export class FeedsApi {
     };
     const body = {
       comment: request?.comment,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -1031,6 +1034,7 @@ export class FeedsApi {
     const body = {
       type: request?.type,
       create_notification_activity: request?.create_notification_activity,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -1554,6 +1558,7 @@ export class FeedsApi {
       create_notification_activity: request?.create_notification_activity,
       follower_role: request?.follower_role,
       push_preference: request?.push_preference,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 
@@ -1581,6 +1586,7 @@ export class FeedsApi {
       target: request?.target,
       create_notification_activity: request?.create_notification_activity,
       push_preference: request?.push_preference,
+      skip_push: request?.skip_push,
       custom: request?.custom,
     };
 

package/src/gen/model-decoders/decoders.ts

@@ -6,7 +6,7 @@ export const decoders: Record<string, Decoder> = {};
 
 const decodeDatetimeType = (input: number | string) =>
   typeof input === 'number'
-    ? new Date(Math.floor(input / 1e6))
+    ? new Date(Math.floor(input / 1000000))
     : new Date(input);
 
 decoders.DatetimeType = decodeDatetimeType;
@@ -584,6 +584,8 @@ decoders.CommentAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
+    activity: { type: 'ActivityResponse', isSingle: true },
+
     comment: { type: 'CommentResponse', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
@@ -606,6 +608,8 @@ decoders.CommentReactionAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
+    activity: { type: 'ActivityResponse', isSingle: true },
+
     comment: { type: 'CommentResponse', isSingle: true },
 
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
@@ -632,6 +636,8 @@ decoders.CommentReactionUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
+    activity: { type: 'ActivityResponse', isSingle: true },
+
     comment: { type: 'CommentResponse', isSingle: true },
 
     reaction: { type: 'FeedsReactionResponse', isSingle: true },
@@ -1128,6 +1134,8 @@ decoders.Message = (input?: Record<string, any>) => {
 
     thread_participants: { type: 'User', isSingle: false },
 
+    member: { type: 'ChannelMember', isSingle: true },
+
     pinned_by: { type: 'User', isSingle: true },
 
     poll: { type: 'Poll', isSingle: true },
@@ -1214,6 +1222,10 @@ decoders.ModerationCustomActionEvent = (input?: Record<string, any>) => {
 
 decoders.ModerationFlagResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
     review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
 
     user: { type: 'UserResponse', isSingle: true },