@stream-io/feeds-client 0.1.9 → 0.1.11

package/src/{FeedsClient.ts → feeds-client.ts}

@@ -11,6 +11,7 @@ import {
   QueryFeedsRequest,
   QueryPollVotesRequest,
   SingleFollowRequest,
+  UpdateFollowRequest,
   UserRequest,
   WSEvent,
 } from './gen/models';
@@ -27,14 +28,19 @@ import {
   streamDevToken,
 } from './common/utils';
 import { decodeWSEvent } from './gen/model-decoders/event-decoder-mapping';
-import { Feed } from './Feed';
 import {
   FeedsClientOptions,
   NetworkChangedEvent,
   StreamResponse,
 } from './common/types';
-import { ModerationClient } from './ModerationClient';
+import { ModerationClient } from './moderation-client';
 import { StreamPoll } from './common/Poll';
+import {
+  Feed,
+  handleFollowCreated,
+  handleFollowDeleted,
+  handleFollowUpdated,
+} from './feed';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -363,6 +369,21 @@ export class FeedsClient extends FeedsApi {
     this.eventDispatcher.dispatch(networkEvent);
   };
 
+  async updateFollow(request: UpdateFollowRequest) {
+    const response = await super.updateFollow(request);
+
+    [response.follow.source_feed.fid, response.follow.target_feed.fid].forEach(
+      (fid) => {
+        const feed = this.activeFeeds[fid];
+        if (feed) {
+          handleFollowUpdated.bind(feed)(response);
+        }
+      },
+    );
+
+    return response;
+  }
+
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
   async follow(request: SingleFollowRequest) {
     const response = await super.follow(request);
@@ -371,7 +392,7 @@ export class FeedsClient extends FeedsApi {
       (fid) => {
         const feed = this.activeFeeds[fid];
         if (feed) {
-          feed.handleFollowCreated(response.follow);
+          handleFollowCreated.bind(feed)(response);
         }
       },
     );
@@ -385,7 +406,7 @@ export class FeedsClient extends FeedsApi {
     response.follows.forEach((follow) => {
       const feed = this.activeFeeds[follow.source_feed.fid];
       if (feed) {
-        feed.handleFollowCreated(follow);
+        handleFollowCreated.bind(feed)({ follow });
       }
     });
 
@@ -398,10 +419,7 @@ export class FeedsClient extends FeedsApi {
     [request.source, request.target].forEach((fid) => {
       const feed = this.activeFeeds[fid];
       if (feed) {
-        feed.handleFollowDeleted({
-          source_feed: { fid: request.source },
-          target_feed: { fid: request.target },
-        });
+        handleFollowDeleted.bind(feed)(response);
       }
     });
 

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

@@ -1709,6 +1709,13 @@ decoders.ThreadedCommentResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UnfollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UnpinActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     activity: { type: 'ActivityResponse', isSingle: true },

package/src/gen/models/index.ts

@@ -4752,12 +4752,20 @@ export interface ReviewQueueItem {
 
   bans: Ban[];
 
+  flag_labels: string[];
+
+  flag_types: string[];
+
   flags: Flag[];
 
   languages: string[];
 
+  reporter_ids: string[];
+
   teams: string[];
 
+  archived_at: NullTime;
+
   completed_at: NullTime;
 
   reviewed_at: NullTime;
@@ -5348,6 +5356,8 @@ export interface UnblockUsersResponse {
 
 export interface UnfollowResponse {
   duration: string;
+
+  follow: FollowResponse;
 }
 
 export interface UnpinActivityResponse {

package/src/gen-imports.ts

@@ -1,3 +1,3 @@
 export type { ApiClient } from './common/ApiClient';
 export type { StreamResponse } from './common/types';
-export { FeedsClient as FeedsApi } from './FeedsClient';
+export { FeedsClient as FeedsApi } from './feeds-client';

package/src/test-utils/index.ts

@@ -0,0 +1 @@
+export * from './response-generators';

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

@@ -0,0 +1,102 @@
+import {
+  FeedResponse,
+  FollowResponse,
+  OwnUser,
+  OwnUserResponse,
+  UserResponse,
+} from '../gen/models';
+import { humanId } from 'human-id';
+
+export const getHumanId = () => humanId({ capitalize: false, separator: '-' });
+
+export const generateUserResponse = (
+  overrides: Partial<UserResponse> = {},
+): UserResponse => ({
+  id: `user-${getHumanId()}`,
+  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 => ({
+  ...generateUserResponse({
+    id: `own-user-${getHumanId()}`,
+  }),
+  invisible: false,
+  total_unread_count: 0,
+  unread_channels: 0,
+  unread_count: 0,
+  unread_threads: 0,
+  channel_mutes: [],
+  devices: [],
+  mutes: [],
+  ...overrides,
+});
+
+export const generateOwnUser = (overrides: Partial<OwnUser> = {}): OwnUser => ({
+  ...generateOwnUserResponse(),
+  devices: [],
+  mutes: [],
+  total_unread_count_by_team: {},
+  ...overrides,
+});
+
+export const generateFeedResponse = (
+  overrides: Omit<Partial<FeedResponse>, 'created_by' | 'fid'> & {
+    created_by?: Partial<UserResponse>;
+  } = {},
+): FeedResponse => {
+  const id = overrides.id || `feed-${getHumanId()}`;
+  const groupId = overrides.group_id || 'user';
+  const fid = `${groupId}:${id}`;
+  const createdBy = generateUserResponse(overrides.created_by);
+  const description = humanId({
+    addAdverb: true,
+    adjectiveCount: 4,
+  });
+  const name = humanId();
+
+  return {
+    id,
+    group_id: groupId,
+    created_at: new Date(),
+    updated_at: new Date(),
+    description,
+    fid,
+    follower_count: 0,
+    following_count: 0,
+    member_count: 0,
+    name,
+    pin_count: 0,
+    custom: {},
+    ...overrides,
+    created_by: createdBy,
+  };
+};
+
+export const generateFollowResponse = (
+  overrides: Partial<FollowResponse> = {},
+): FollowResponse => {
+  const sourceFeedResponse = generateFeedResponse();
+  const targetFeedResponse = generateFeedResponse();
+
+  return {
+    created_at: new Date(),
+    updated_at: new Date(),
+    follower_role: 'user',
+    push_preference: 'all',
+    status: 'accepted',
+    source_feed: sourceFeedResponse,
+    target_feed: targetFeedResponse,
+    ...overrides,
+  };
+};

package/src/types-internal.ts

@@ -1,5 +1,16 @@
+import { WSEvent } from './gen/models';
+
 export type UpdateStateResult<T> = T & {
   changed: boolean;
 };
 
 export type FromArray<T> = T extends Array<infer L> ? L : never;
+
+export type EventPayload<T extends WSEvent['type']> = Extract<
+  WSEvent,
+  { type: T }
+>;
+
+export type PartializeAllBut<T, K extends keyof T> = Pick<T, K> & {
+  [key in K]?: T[key];
+};

package/src/types.ts

@@ -8,7 +8,7 @@ import type {
   ActivityResponse,
   CommentResponse,
 } from './gen/models';
-import { FeedsClient } from './FeedsClient';
+import { FeedsClient } from './feeds-client';
 
 export type FeedsEvent = WSEvent | ConnectionChangedEvent | NetworkChangedEvent;
 export type ActivityIdOrCommentId = string;

package/src/utils/check-has-another-page.ts

@@ -0,0 +1,6 @@
+export const checkHasAnotherPage = <T extends unknown | undefined>(
+  v: T,
+  cursor: string | undefined,
+) =>
+  (typeof v === 'undefined' && typeof cursor === 'undefined') ||
+  typeof cursor === 'string';

package/src/utils/constants.ts

@@ -0,0 +1,3 @@
+export const Constants = {
+  DEFAULT_COMMENT_PAGINATION: 'first',
+} as const;

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './check-has-another-page';
+export * from './unique-array-merge';
+export * from './constants';
+export * from './type-assertions';
+export * from './state-update-queue';

package/src/{state-updates → utils}/state-update-queue.test.ts

@@ -6,7 +6,7 @@ describe('state-update-queue', () => {
   describe('shouldUpdateState', () => {
     it('should return true when watch is false', () => {
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue: new Set(['other-id']),
         watch: false,
       });
@@ -14,11 +14,11 @@ describe('state-update-queue', () => {
       expect(result).toBe(true);
     });
 
-    it('should return true when watch is true but stateUpdateId is not in queue', () => {
+    it('should return true when watch is true but queueId is not in queue', () => {
       const stateUpdateQueue = new Set(['other-id-1', 'other-id-2']);
 
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue: stateUpdateQueue,
         watch: true,
       });
@@ -27,11 +27,11 @@ describe('state-update-queue', () => {
       expect(result).toBe(true);
     });
 
-    it('should return false and remove stateUpdateId from queue when watch is true and stateUpdateId is in queue', () => {
+    it('should return false and remove queueId from queue when watch is true and queueId is in queue', () => {
       const stateUpdateQueue = new Set(['test-id', 'other-id']);
 
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue,
         watch: true,
       });
@@ -42,7 +42,7 @@ describe('state-update-queue', () => {
 
     it('should handle empty queue when watch is true', () => {
       const result = shouldUpdateState({
-        stateUpdateId: 'test-id',
+        stateUpdateQueueId: 'test-id',
         stateUpdateQueue: new Set(),
         watch: true,
       });

package/src/utils/state-update-queue.ts

@@ -0,0 +1,42 @@
+import { isFollowResponse } from './type-assertions';
+
+export const shouldUpdateState = ({
+  stateUpdateQueueId,
+  stateUpdateQueue,
+  watch,
+}: {
+  stateUpdateQueueId: string;
+  stateUpdateQueue: Set<string>;
+  watch: boolean;
+}) => {
+  if (!watch) {
+    return true;
+  }
+
+  if (watch && stateUpdateQueue.has(stateUpdateQueueId)) {
+    stateUpdateQueue.delete(stateUpdateQueueId);
+    return false;
+  }
+
+  stateUpdateQueue.add(stateUpdateQueueId);
+  return true;
+};
+
+export function getStateUpdateQueueId(
+  data: object,
+  prefix?: 'deleted' | 'updated' | 'created' | (string & {}),
+) {
+  if (isFollowResponse(data)) {
+    const toJoin = [data.source_feed.fid, data.target_feed.fid];
+    if (prefix) {
+      toJoin.unshift(prefix);
+    }
+    return toJoin.join('-');
+  }
+  // else if (isMemberResponse(data)) {
+  // }
+
+  throw new Error(
+    `Cannot create state update queueId for data: ${JSON.stringify(data)}`,
+  );
+}

package/src/utils/type-assertions.ts

@@ -0,0 +1,22 @@
+import { CommentResponse, FollowResponse } from '../gen/models';
+import { StreamFile } from '../types';
+import { CommentParent } from '../types';
+
+export const isFollowResponse = (data: object): data is FollowResponse => {
+  return 'source_feed' in data && 'target_feed' in data;
+};
+
+export const isCommentResponse = (
+  entity: CommentParent,
+): entity is CommentResponse => {
+  return typeof (entity as CommentResponse)?.object_id === 'string';
+};
+
+export const isImageFile = (file: StreamFile) => {
+  // photoshop files begin with 'image/'
+  return file.type.startsWith('image/') && !file.type.endsWith('.photoshop');
+};
+
+export const isVideoFile = (file: StreamFile) => {
+  return file.type.startsWith('video/');
+};

package/src/{utils.test.ts → utils/unique-array-merge.test.ts}

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest';
 
-import { uniqueArrayMerge } from './utils';
+import { uniqueArrayMerge } from './unique-array-merge';
 
 describe('utils', () => {
-  describe('uniqueMerge', () => {
+  describe(uniqueArrayMerge.name, () => {
     it('should merge arrays with unique objects based on key', () => {
       const existingArray = [
         { id: '1', name: 'Alice' },
@@ -123,7 +123,11 @@ describe('utils', () => {
         email: string;
       }) => item.email;
 
-      const result = uniqueArrayMerge(existingArray, arrayToMerge, getKeyByEmail);
+      const result = uniqueArrayMerge(
+        existingArray,
+        arrayToMerge,
+        getKeyByEmail,
+      );
 
       expect(result).toEqual([
         { id: '1', name: 'Alice', email: 'alice@example.com' },

package/src/utils/unique-array-merge.ts

@@ -0,0 +1,19 @@
+export const uniqueArrayMerge = <T>(
+  existingArray: T[],
+  arrayToMerge: T[],
+  getKey: (v: T) => string,
+) => {
+  const existing = new Set<string>();
+
+  existingArray.forEach((value) => {
+    const key = getKey(value);
+    existing.add(key);
+  });
+
+  const filteredArrayToMerge = arrayToMerge.filter((value) => {
+    const key = getKey(value);
+    return !existing.has(key);
+  });
+
+  return existingArray.concat(filteredArrayToMerge);
+};

package/dist/src/state-updates/activity-reaction-utils.d.ts

@@ -1,10 +0,0 @@
-import { ActivityReactionAddedEvent, ActivityReactionDeletedEvent, ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const addReactionToActivity: (event: ActivityReactionAddedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const removeReactionFromActivity: (event: ActivityReactionDeletedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const addReactionToActivities: (event: ActivityReactionAddedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const removeReactionFromActivities: (event: ActivityReactionDeletedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;

package/dist/src/state-updates/activity-utils.d.ts

@@ -1,13 +0,0 @@
-import { ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const addActivitiesToState: (newActivities: ActivityResponse[], activities: ActivityResponse[] | undefined, position: "start" | "end") => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const updateActivityInState: (updatedActivityResponse: ActivityResponse, activities: ActivityResponse[]) => {
-    changed: boolean;
-    activities: ActivityResponse[];
-};
-export declare const removeActivityFromState: (activityResponse: ActivityResponse, activities: ActivityResponse[]) => {
-    changed: boolean;
-    activities: ActivityResponse[];
-};

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

@@ -1,14 +0,0 @@
-import { BookmarkAddedEvent, BookmarkDeletedEvent, BookmarkUpdatedEvent, ActivityResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const addBookmarkToActivity: (event: BookmarkAddedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const removeBookmarkFromActivity: (event: BookmarkDeletedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const updateBookmarkInActivity: (event: BookmarkUpdatedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const addBookmarkToActivities: (event: BookmarkAddedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const removeBookmarkFromActivities: (event: BookmarkDeletedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const updateBookmarkInActivities: (event: BookmarkUpdatedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;

package/dist/src/state-updates/follow-utils.d.ts

@@ -1,19 +0,0 @@
-import { FeedState } from '../Feed';
-import { FollowResponse } from '../gen/models';
-import { UpdateStateResult } from '../types-internal';
-export declare const handleFollowCreated: (follow: FollowResponse, currentState: FeedState, currentFeedId: string, connectedUserId?: string) => UpdateStateResult<{
-    data: FeedState;
-}>;
-export declare const handleFollowDeleted: (follow: FollowResponse | {
-    source_feed: {
-        fid: string;
-    };
-    target_feed: {
-        fid: string;
-    };
-}, currentState: FeedState, currentFeedId: string, connectedUserId?: string) => UpdateStateResult<{
-    data: FeedState;
-}>;
-export declare const handleFollowUpdated: (currentState: FeedState) => UpdateStateResult<{
-    data: FeedState;
-}>;

package/dist/src/state-updates/state-update-queue.d.ts

@@ -1,15 +0,0 @@
-import { FollowResponse } from '../gen/models';
-export declare const shouldUpdateState: ({ stateUpdateId, stateUpdateQueue, watch, }: {
-    stateUpdateId: string;
-    stateUpdateQueue: Set<string>;
-    watch: boolean;
-}) => boolean;
-export declare const getStateUpdateQueueIdForFollow: (follow: FollowResponse) => string;
-export declare const getStateUpdateQueueIdForUnfollow: (follow: FollowResponse | {
-    source_feed: {
-        fid: string;
-    };
-    target_feed: {
-        fid: string;
-    };
-}) => string;

package/dist/src/utils.d.ts

@@ -1,10 +0,0 @@
-import { CommentParent, StreamFile } from './types';
-import type { CommentResponse } from './gen/models';
-export declare const isImageFile: (file: StreamFile) => boolean;
-export declare const isVideoFile: (file: StreamFile) => boolean;
-export declare const checkHasAnotherPage: <T extends unknown | undefined>(v: T, cursor: string | undefined) => boolean;
-export declare const isCommentResponse: (entity: CommentParent) => entity is CommentResponse;
-export declare const Constants: {
-    readonly DEFAULT_COMMENT_PAGINATION: "first";
-};
-export declare const uniqueArrayMerge: <T>(existingArray: T[], arrayToMerge: T[], getKey: (v: T) => string) => T[];

package/src/state-updates/activity-reaction-utils.ts

@@ -1,107 +0,0 @@
-import {
-  ActivityReactionAddedEvent,
-  ActivityReactionDeletedEvent,
-  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 addReactionToActivity = (
-  event: ActivityReactionAddedEvent,
-  activity: ActivityResponse,
-  isCurrentUser: boolean,
-): UpdateStateResult<ActivityResponse> => {
-  // Update own_reactions if the reaction is from the current user
-  const ownReactions = [...(activity.own_reactions || [])];
-  if (isCurrentUser) {
-    ownReactions.push(event.reaction);
-  }
-
-  return {
-    ...activity,
-    own_reactions: ownReactions,
-    latest_reactions: event.activity.latest_reactions,
-    reaction_groups: event.activity.reaction_groups,
-    changed: true,
-  };
-};
-
-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 addReactionToActivities = (
-  event: ActivityReactionAddedEvent,
-  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 = addReactionToActivity(event, activity, isCurrentUser);
-  return updateActivityInActivities(updatedActivity, activities);
-};
-
-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 updateActivityInActivities(updatedActivity, activities);
-};