@stream-io/feeds-client 0.2.1 → 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.1",
+  "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-marked-utils.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ActivityMarkEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import { updateNotificationStatusFromActivityMarked } from './handle-activity-marked';
+
+const createMockActivityMarkEvent = (
+  overrides: Partial<ActivityMarkEvent> = {},
+): ActivityMarkEvent => ({
+  created_at: new Date(),
+  fid: 'user:notification',
+  custom: {},
+  type: 'feeds.activity.marked',
+  ...overrides,
+});
+
+const createMockNotificationStatus = (
+  overrides: Partial<NotificationStatusResponse> = {},
+): NotificationStatusResponse => ({
+  unread: 0,
+  unseen: 0,
+  ...overrides,
+});
+
+const createMockAggregatedActivity = (group: string) => ({ group });
+
+describe('activity-marked-utils', () => {
+  describe('updateNotificationStatusFromActivityMarked', () => {
+    it('should return unchanged if notification_status is undefined', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = undefined;
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(false);
+    });
+
+    it('should handle mark_all_read by adding all aggregated activity groups', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+        createMockAggregatedActivity('group3'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'group1',
+        'group2',
+        'group3',
+      ]);
+    });
+
+    it('should handle mark_read by adding specific activity IDs', () => {
+      const event = createMockActivityMarkEvent({
+        mark_read: ['activity1', 'activity2'],
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'activity1',
+        'activity2',
+      ]);
+    });
+
+    it('should handle mark_all_seen by setting last_seen_at to current date', () => {
+      const event = createMockActivityMarkEvent({ mark_all_seen: true });
+      const currentStatus = createMockNotificationStatus({
+        last_seen_at: new Date('2023-01-01'),
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+      expect(
+        result.data?.notification_status.last_seen_at!.getTime(),
+      ).toBeGreaterThan(new Date('2023-01-01').getTime());
+    });
+
+    it('should handle multiple mark flags simultaneously', () => {
+      const event = createMockActivityMarkEvent({
+        mark_all_read: true,
+        mark_all_seen: true,
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+        last_seen_at: new Date('2023-01-01'),
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'group1',
+        'group2',
+      ]);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+    });
+
+    it('should deduplicate read activities when adding new ones', () => {
+      const event = createMockActivityMarkEvent({
+        mark_read: ['activity1', 'activity1', 'activity2'],
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1', 'activity1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'activity1',
+        'activity2',
+      ]);
+    });
+
+    it('should preserve existing notification status fields', () => {
+      const event = createMockActivityMarkEvent({ mark_all_seen: true });
+      const currentStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['existing1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.unread).toBe(5);
+      expect(result.data?.notification_status.unseen).toBe(3);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+      ]);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+    });
+
+    it('should handle mark_all_read with no existing read_activities', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: undefined,
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'group1',
+        'group2',
+      ]);
+    });
+  });
+});

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', () => {