@stream-io/feeds-client 0.2.2 → 0.2.3

package/index.ts

@@ -4,10 +4,6 @@ export * from './src/gen/models';
 export * from './src/types';
 export * from './src/common/types';
 export * from './src/common/StateStore';
-export * from './src/common/BaseSearchSource';
-export * from './src/common/SearchController';
-export * from './src/common/ActivitySearchSource';
-export * from './src/common/UserSearchSource';
-export * from './src/common/FeedSearchSource';
+export * from './src/common/search';
 export * from './src/common/Poll';
 export * from './src/utils';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {

package/src/common/{ActivitySearchSource.ts → search/ActivitySearchSource.ts}

@@ -1,8 +1,8 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { SearchSourceOptions } from './BaseSearchSource';
+import type { SearchSourceOptions } from './types';
 
-import { FeedsClient } from '../feeds-client';
-import { ActivityResponse } from '../gen/models';
+import { FeedsClient } from '../../feeds-client';
+import { ActivityResponse } from '../../gen/models';
 
 export class ActivitySearchSource extends BaseSearchSource<ActivityResponse> {
   readonly type = 'activity' as const;

package/src/common/{BaseSearchSource.ts → search/BaseSearchSource.ts}

@@ -1,22 +1,20 @@
-import { StateStore } from './StateStore';
-import { debounce, type DebouncedFunc } from './utils';
-
-export type SearchSourceType = 'activity' | 'user' | 'feed' | (string & {});
-
-export type QueryReturnValue<T> = { items: T[]; next?: string | null };
+import { StateStore } from '../StateStore';
+import { debounce, type DebouncedFunc } from '../utils';
+import type {
+  QueryReturnValue,
+  SearchSourceOptions,
+  SearchSourceState,
+  SearchSourceType,
+} from './types';
 
 export type DebounceOptions = {
   debounceMs: number;
 };
-type DebouncedExecQueryFunction = DebouncedFunc<
-  (searchString?: string) => Promise<void>
->;
+type DebouncedExecQueryFunction = DebouncedFunc<(searchString?: string) => Promise<void>>;
 
-export interface SearchSource<T = any> {
+interface ISearchSource<T = any> {
   activate(): void;
 
-  cancelScheduledQuery(): void;
-
   canExecuteQuery(newSearchString?: string): boolean;
 
   deactivate(): void;
@@ -33,54 +31,44 @@ export interface SearchSource<T = any> {
 
   resetState(): void;
 
-  search(text?: string): Promise<void> | undefined;
-
   readonly searchQuery: string;
 
-  setDebounceOptions(options: DebounceOptions): void;
-
   readonly state: StateStore<SearchSourceState<T>>;
   readonly type: SearchSourceType;
 }
 
-export type SearchSourceState<T = any> = {
-  hasNext: boolean;
-  isActive: boolean;
-  isLoading: boolean;
-  items: T[] | undefined;
-  searchQuery: string;
-  lastQueryError?: Error;
-  next?: string | null;
-  offset?: number;
-};
-export type SearchSourceOptions = {
-  /** The number of milliseconds to debounce the search query. The default interval is 300ms. */
-  debounceMs?: number;
-  pageSize?: number;
-  allowEmptySearchString?: boolean;
-};
+export interface SearchSource<T = any> extends ISearchSource<T> {
+  cancelScheduledQuery(): void;
+  setDebounceOptions(options: DebounceOptions): void;
+  search(text?: string): Promise<void> | undefined;
+}
+
+export interface SearchSourceSync<T = any> extends ISearchSource<T> {
+  cancelScheduledQuery(): void;
+  setDebounceOptions(options: DebounceOptions): void;
+  search(text?: string): void;
+}
+
 const DEFAULT_SEARCH_SOURCE_OPTIONS: Required<SearchSourceOptions> = {
   debounceMs: 300,
   pageSize: 10,
   allowEmptySearchString: false,
+  resetOnNewSearchQuery: true,
 } as const;
 
-export abstract class BaseSearchSource<T> implements SearchSource<T> {
+abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
   state: StateStore<SearchSourceState<T>>;
-  protected pageSize: number;
+  pageSize: number;
   protected allowEmptySearchString: boolean;
+  protected resetOnNewSearchQuery: boolean;
   abstract readonly type: SearchSourceType;
-  protected searchDebounced!: DebouncedExecQueryFunction;
 
   protected constructor(options?: SearchSourceOptions) {
-    const { debounceMs, pageSize, allowEmptySearchString } = {
-      ...DEFAULT_SEARCH_SOURCE_OPTIONS,
-      ...options,
-    };
+    const { pageSize, allowEmptySearchString, resetOnNewSearchQuery } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
     this.pageSize = pageSize;
     this.allowEmptySearchString = allowEmptySearchString;
+    this.resetOnNewSearchQuery = resetOnNewSearchQuery;
     this.state = new StateStore<SearchSourceState<T>>(this.initialState);
-    this.setDebounceOptions({ debounceMs });
   }
 
   get lastQueryError() {
@@ -132,14 +120,6 @@ export abstract class BaseSearchSource<T> implements SearchSource<T> {
     return this.state.getLatestValue().searchQuery;
   }
 
-  protected abstract query(searchQuery: string): Promise<QueryReturnValue<T>>;
-
-  protected abstract filterQueryResults(items: T[]): T[] | Promise<T[]>;
-
-  setDebounceOptions = ({ debounceMs }: DebounceOptions) => {
-    this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-  };
-
   activate = () => {
     if (this.isActive) return;
     this.state.partialNext({ isActive: true });
@@ -161,13 +141,16 @@ export abstract class BaseSearchSource<T> implements SearchSource<T> {
     );
   };
 
-  protected getStateBeforeFirstQuery(
-    newSearchString: string,
-  ): SearchSourceState<T> {
+  protected getStateBeforeFirstQuery(newSearchString: string): SearchSourceState<T> {
+    const initialState = this.initialState;
+    const oldItems = this.items;
+
+    const items = this.resetOnNewSearchQuery ? initialState.items : oldItems;
     return {
       ...this.initialState,
+      items,
       isActive: this.isActive,
-      isLoading: true,
+      isLoading: this.resetOnNewSearchQuery ? true : !oldItems,
       searchQuery: newSearchString,
     };
   }
@@ -184,12 +167,11 @@ export abstract class BaseSearchSource<T> implements SearchSource<T> {
       isLoading: false,
       items: isFirstPage
         ? stateUpdate.items
-        : [...(this.items ?? []), ...(stateUpdate.items ?? [])],
+        : [...(this.items ?? []), ...(stateUpdate.items || [])],
     };
   }
 
-  async executeQuery(newSearchString?: string) {
-    if (!this.canExecuteQuery(newSearchString)) return;
+  protected prepareStateForQuery(newSearchString?: string) {
     const hasNewSearchQuery = typeof newSearchString !== 'undefined';
     const searchString = newSearchString ?? this.searchQuery;
 
@@ -199,20 +181,67 @@ export abstract class BaseSearchSource<T> implements SearchSource<T> {
       this.state.partialNext({ isLoading: true });
     }
 
+    return { searchString, hasNewSearchQuery };
+  }
+
+  protected updatePaginationStateFromQuery(result: QueryReturnValue<T>) {
+    const { items, next } = result;
+
     const stateUpdate: Partial<SearchSourceState<T>> = {};
+    if (next || next === null) {
+      stateUpdate.next = next;
+      stateUpdate.hasNext = !!next;
+    } else {
+      stateUpdate.offset = (this.offset ?? 0) + items.length;
+      stateUpdate.hasNext = items.length === this.pageSize;
+    }
+
+    return stateUpdate;
+  }
+
+  resetState() {
+    this.state.next(this.initialState);
+  }
+
+  resetStateAndActivate() {
+    this.resetState();
+    this.activate();
+  }
+}
+
+export abstract class BaseSearchSource<T>
+  extends BaseSearchSourceBase<T>
+  implements SearchSource<T>
+{
+  protected searchDebounced!: DebouncedExecQueryFunction;
+
+  constructor(options?: SearchSourceOptions) {
+    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
+    super(options);
+    this.setDebounceOptions({ debounceMs });
+  }
+
+  protected abstract query(searchQuery: string): Promise<QueryReturnValue<T>>;
+
+  protected abstract filterQueryResults(items: T[]): T[] | Promise<T[]>;
+
+  setDebounceOptions = ({ debounceMs }: DebounceOptions) => {
+    this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
+  };
+
+  async executeQuery(newSearchString?: string) {
+    if (!this.canExecuteQuery(newSearchString)) return;
+
+    const { hasNewSearchQuery, searchString } =
+      this.prepareStateForQuery(newSearchString);
+
+    let stateUpdate: Partial<SearchSourceState<T>> = {};
     try {
       const results = await this.query(searchString);
       if (!results) return;
-      const { items, next } = results;
-
-      if (typeof next === 'string' || next === null) {
-        stateUpdate.next = next;
-        stateUpdate.hasNext = !!next;
-      } else {
-        stateUpdate.offset = (this.offset ?? 0) + items.length;
-        stateUpdate.hasNext = items.length === this.pageSize;
-      }
 
+      const { items } = results;
+      stateUpdate = this.updatePaginationStateFromQuery(results);
       stateUpdate.items = await this.filterQueryResults(items);
     } catch (e) {
       stateUpdate.lastQueryError = e as Error;
@@ -226,13 +255,52 @@ export abstract class BaseSearchSource<T> implements SearchSource<T> {
   cancelScheduledQuery() {
     this.searchDebounced.cancel();
   }
+}
 
-  resetState() {
-    this.state.next(this.initialState);
+export abstract class BaseSearchSourceSync<T>
+  extends BaseSearchSourceBase<T>
+  implements SearchSourceSync<T>
+{
+  protected searchDebounced!: DebouncedExecQueryFunction;
+
+  constructor(options?: SearchSourceOptions) {
+    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
+    super(options);
+    this.setDebounceOptions({ debounceMs });
   }
 
-  resetStateAndActivate() {
-    this.resetState();
-    this.activate();
+  protected abstract query(searchQuery: string): QueryReturnValue<T>;
+
+  protected abstract filterQueryResults(items: T[]): T[];
+
+  setDebounceOptions = ({ debounceMs }: DebounceOptions) => {
+    this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
+  };
+
+  executeQuery(newSearchString?: string) {
+    if (!this.canExecuteQuery(newSearchString)) return;
+
+    const { hasNewSearchQuery, searchString } =
+      this.prepareStateForQuery(newSearchString);
+
+    let stateUpdate: Partial<SearchSourceState<T>> = {};
+    try {
+      const results = this.query(searchString);
+      if (!results) return;
+
+      const { items } = results;
+      stateUpdate = this.updatePaginationStateFromQuery(results);
+      stateUpdate.items = this.filterQueryResults(items);
+    } catch (e) {
+      stateUpdate.lastQueryError = e as Error;
+    } finally {
+      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+    }
+  }
+
+  search = (searchQuery?: string) => this.searchDebounced(searchQuery);
+
+  cancelScheduledQuery() {
+    this.searchDebounced.cancel();
   }
 }

package/src/common/{FeedSearchSource.ts → search/FeedSearchSource.ts}

@@ -1,8 +1,8 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { SearchSourceOptions } from './BaseSearchSource';
+import type { SearchSourceOptions } from './types';
 
-import { FeedsClient } from '../feeds-client';
-import { Feed } from '../feed';
+import { FeedsClient } from '../../feeds-client';
+import { Feed } from '../../feed';
 
 export type FeedSearchSourceOptions = SearchSourceOptions & {
   groupId?: string;

package/src/common/{SearchController.ts → search/SearchController.ts}

@@ -1,4 +1,4 @@
-import { StateStore } from './StateStore';
+import { StateStore } from '../StateStore';
 import type { SearchSource } from './BaseSearchSource';
 
 export type SearchControllerState = {
@@ -23,8 +23,6 @@ export class SearchController {
   /**
    * Not intended for direct use by integrators, might be removed without notice resulting in
    * broken integrations.
-   *
-   * @internal
    */
   _internalState: StateStore<InternalSearchControllerState>;
   state: StateStore<SearchControllerState>;
@@ -39,7 +37,6 @@ export class SearchController {
     this._internalState = new StateStore<InternalSearchControllerState>({});
     this.config = { keepSingleActiveSource: true, ...config };
   }
-
   get hasNext() {
     return this.sources.some((source) => source.hasNext);
   }
@@ -117,9 +114,7 @@ export class SearchController {
     this.state.partialNext({
       searchQuery,
     });
-    await Promise.all(
-      searchedSources.map((source) => source.search(searchQuery)),
-    );
+    await Promise.all(searchedSources.map((source) => source.search(searchQuery)));
   };
 
   cancelSearchQueries = () => {

package/src/common/{UserSearchSource.ts → search/UserSearchSource.ts}

@@ -1,8 +1,8 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { SearchSourceOptions } from './BaseSearchSource';
+import type { SearchSourceOptions } from './types';
 
-import { FeedsClient } from '../feeds-client';
-import { UserResponse } from '../gen/models';
+import { FeedsClient } from '../../feeds-client';
+import { UserResponse } from '../../gen/models';
 
 export class UserSearchSource extends BaseSearchSource<UserResponse> {
   readonly type = 'user' as const;

package/src/common/search/index.ts

@@ -0,0 +1,6 @@
+export * from './SearchController';
+export * from './BaseSearchSource';
+export * from './ActivitySearchSource';
+export * from './FeedSearchSource';
+export * from './UserSearchSource';
+export * from './types';

package/src/common/search/types.ts

@@ -0,0 +1,21 @@
+export type SearchSourceState<T = any> = {
+  hasNext: boolean;
+  isActive: boolean;
+  isLoading: boolean;
+  items: T[] | undefined;
+  searchQuery: string;
+  lastQueryError?: Error;
+  next?: string | null;
+  offset?: number;
+};
+
+export type SearchSourceOptions = {
+  /** The number of milliseconds to debounce the search query. The default interval is 300ms. */
+  debounceMs?: number;
+  pageSize?: number;
+  allowEmptySearchString?: boolean;
+  resetOnNewSearchQuery?: boolean;
+};
+
+export type SearchSourceType = 'activity' | 'user' | 'feed' | (string & {});
+export type QueryReturnValue<T> = { items: T[]; next?: string | null };

package/src/common/types.ts

@@ -1,3 +1,5 @@
+export * from './search/types';
+
 export type FeedsClientOptions = {
   base_url?: string;
   timeout?: number;

package/src/feed/event-handlers/activity/activity-utils.test.ts

@@ -191,7 +191,7 @@ describe('activity-utils', () => {
 
       expect(result.changed).toBe(true);
       expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].id).toBe('activity2');
+      expect(result.activities![0].id).toBe('activity2');
       // Make sure we create a new array
       expect(activities === result.activities).toBe(false);
     });
@@ -205,7 +205,7 @@ describe('activity-utils', () => {
 
       expect(result.changed).toBe(false);
       expect(result.activities).toHaveLength(1);
-      expect(result.activities[0].id).toBe('activity1');
+      expect(result.activities![0].id).toBe('activity1');
     });
 
     it('should handle empty activities array', () => {

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

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityAdded } from './handle-activity-added';
+import {
+  generateActivityAddedEvent,
+  generateActivityResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleActivityAdded.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('initializes activities when state is empty and adds new activity to the start', () => {
+    const event = generateActivityAddedEvent();
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.activities).toBeUndefined();
+
+    const hydrateSpy = vi.spyOn(client, 'hydratePollCache');
+
+    handleActivityAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toBeDefined();
+    expect(stateAfter.activities).toHaveLength(1);
+    expect(stateAfter.activities?.[0]).toBe(event.activity);
+    expect(hydrateSpy).toHaveBeenCalledWith([event.activity]);
+  });
+
+  it('prepends new activity when activities already exist', () => {
+    const existing = generateActivityResponse();
+    feed.state.partialNext({ activities: [existing] });
+
+    const event = generateActivityAddedEvent();
+
+    handleActivityAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toHaveLength(2);
+    expect(stateAfter.activities?.[0]).toBe(event.activity);
+    expect(stateAfter.activities?.[1]).toBe(existing);
+  });
+
+  it('does not duplicate if activity already exists', () => {
+    const existing = generateActivityResponse();
+    feed.state.partialNext({ activities: [existing] });
+
+    const event = generateActivityAddedEvent({
+      activity: { id: existing.id },
+    });
+
+    const stateBefore = feed.currentState;
+    handleActivityAdded.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).toBe(stateBefore);
+    expect(stateAfter.activities).toHaveLength(1);
+    expect(stateAfter.activities?.[0]).toBe(existing);
+  });
+});

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

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityDeleted } from './handle-activity-deleted';
+import {
+  generateActivityDeletedEvent,
+  generateActivityPinResponse,
+  generateActivityResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleActivityDeleted.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 the activity from activities array when present', () => {
+    const activity1 = generateActivityResponse();
+    const activity2 = generateActivityResponse();
+    feed.state.partialNext({ activities: [activity1, activity2] });
+
+    const event = generateActivityDeletedEvent({
+      activity: { id: activity1.id },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.activities).toHaveLength(2);
+
+    handleActivityDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toHaveLength(1);
+    expect(stateAfter.activities?.[0].id).toBe(activity2.id);
+  });
+
+  it('removes the activity from pinned_activities when present', () => {
+    const pin1 = generateActivityPinResponse();
+    const pin2 = generateActivityPinResponse();
+    feed.state.partialNext({ pinned_activities: [pin1, pin2] });
+
+    const event = generateActivityDeletedEvent({
+      activity: { id: pin1.activity.id },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.pinned_activities).toHaveLength(2);
+
+    handleActivityDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.pinned_activities).toHaveLength(1);
+    expect(stateAfter.pinned_activities?.[0]).toBe(pin2);
+  });
+
+  it('updates both arrays when the activity exists in both activities and pinned_activities', () => {
+    const sharedId = getHumanId();
+    const activity = generateActivityResponse({ id: sharedId });
+    const pinnedActivity = generateActivityPinResponse({
+      activity: { id: sharedId },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [pinnedActivity],
+    });
+
+    const event = generateActivityDeletedEvent({
+      activity: { id: sharedId },
+    });
+
+    handleActivityDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toHaveLength(0);
+    expect(stateAfter.pinned_activities).toHaveLength(0);
+  });
+
+  it('does nothing if the activity is not found in either list', () => {
+    const activity = generateActivityResponse();
+    const pinnedActivity = generateActivityPinResponse();
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [pinnedActivity],
+    });
+
+    const event = generateActivityDeletedEvent({ activity: { id: 'unknown' } });
+
+    const stateBefore = feed.currentState;
+    handleActivityDeleted.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

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

@@ -3,12 +3,14 @@ import type {
   ActivityPinResponse,
   ActivityResponse,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
 
 export const removeActivityFromState = (
   activityResponse: ActivityResponse,
   activities: ActivityResponse[] | undefined,
-) => {
+): UpdateStateResult<{
+  activities: ActivityResponse[] | undefined;
+}> => {
   const index =
     activities?.findIndex((activity) => activity.id === activityResponse.id) ??
     -1;
@@ -25,7 +27,9 @@ export const removeActivityFromState = (
 export const removePinnedActivityFromState = (
   activityResponse: ActivityResponse,
   pinnedActivities: ActivityPinResponse[] | undefined,
-) => {
+): UpdateStateResult<{
+  pinned_activities: ActivityPinResponse[] | undefined;
+}> => {
   const index =
     pinnedActivities?.findIndex(
       (pinnedActivity) => pinnedActivity.activity.id === activityResponse.id,
@@ -34,7 +38,7 @@ export const removePinnedActivityFromState = (
   if (index !== -1) {
     const newActivities = [...pinnedActivities!];
     newActivities.splice(index, 1);
-    return { changed: true, activities: newActivities };
+    return { changed: true, pinned_activities: newActivities };
   } else {
     return { changed: false, pinned_activities: pinnedActivities };
   }