@stream-io/feeds-client 0.1.0

package/src/common/BaseSearchSource.ts

@@ -0,0 +1,238 @@
+import { StateStore } from './StateStore';
+import { debounce, type DebouncedFunc } from './utils';
+
+export type SearchSourceType =
+  | 'channels'
+  | 'users'
+  | 'messages'
+  | (string & {});
+export type QueryReturnValue<T> = { items: T[]; next?: string | null };
+export type DebounceOptions = {
+  debounceMs: number;
+};
+type DebouncedExecQueryFunction = DebouncedFunc<
+  (searchString?: string) => Promise<void>
+>;
+
+ 
+export interface SearchSource<T = any> {
+  activate(): void;
+
+  cancelScheduledQuery(): void;
+
+  canExecuteQuery(newSearchString?: string): boolean;
+
+  deactivate(): void;
+
+  readonly hasNext: boolean;
+  readonly hasResults: boolean;
+  readonly initialState: SearchSourceState<T>;
+  readonly isActive: boolean;
+  readonly isLoading: boolean;
+  readonly items: T[] | undefined;
+  readonly lastQueryError: Error | undefined;
+  readonly next: string | undefined | null;
+  readonly offset: number | undefined;
+
+  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;
+};
+const DEFAULT_SEARCH_SOURCE_OPTIONS: Required<SearchSourceOptions> = {
+  debounceMs: 300,
+  pageSize: 10,
+} as const;
+
+export abstract class BaseSearchSource<T> implements SearchSource<T> {
+  state: StateStore<SearchSourceState<T>>;
+  protected pageSize: number;
+  abstract readonly type: SearchSourceType;
+  protected searchDebounced!: DebouncedExecQueryFunction;
+
+  protected constructor(options?: SearchSourceOptions) {
+    const { debounceMs, pageSize } = {
+      ...DEFAULT_SEARCH_SOURCE_OPTIONS,
+      ...options,
+    };
+    this.pageSize = pageSize;
+    this.state = new StateStore<SearchSourceState<T>>(this.initialState);
+    this.setDebounceOptions({ debounceMs });
+  }
+
+  get lastQueryError() {
+    return this.state.getLatestValue().lastQueryError;
+  }
+
+  get hasNext() {
+    return this.state.getLatestValue().hasNext;
+  }
+
+  get hasResults() {
+    return Array.isArray(this.state.getLatestValue().items);
+  }
+
+  get isActive() {
+    return this.state.getLatestValue().isActive;
+  }
+
+  get isLoading() {
+    return this.state.getLatestValue().isLoading;
+  }
+
+  get initialState() {
+    return {
+      hasNext: true,
+      isActive: false,
+      isLoading: false,
+      items: undefined,
+      lastQueryError: undefined,
+      next: undefined,
+      offset: 0,
+      searchQuery: '',
+    };
+  }
+
+  get items() {
+    return this.state.getLatestValue().items;
+  }
+
+  get next() {
+    return this.state.getLatestValue().next;
+  }
+
+  get offset() {
+    return this.state.getLatestValue().offset;
+  }
+
+  get searchQuery() {
+    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 });
+  };
+
+  deactivate = () => {
+    if (!this.isActive) return;
+    this.state.partialNext({ isActive: false });
+  };
+
+  canExecuteQuery = (newSearchString?: string) => {
+    const hasNewSearchQuery = typeof newSearchString !== 'undefined';
+    const searchString = newSearchString ?? this.searchQuery;
+    return !!(
+      this.isActive &&
+      !this.isLoading &&
+      (this.hasNext || hasNewSearchQuery) &&
+      searchString
+    );
+  };
+
+  protected getStateBeforeFirstQuery(
+    newSearchString: string,
+  ): SearchSourceState<T> {
+    return {
+      ...this.initialState,
+      isActive: this.isActive,
+      isLoading: true,
+      searchQuery: newSearchString,
+    };
+  }
+
+  protected getStateAfterQuery(
+    stateUpdate: Partial<SearchSourceState<T>>,
+    isFirstPage: boolean,
+  ): SearchSourceState<T> {
+    const current = this.state.getLatestValue();
+    return {
+      ...current,
+      lastQueryError: undefined, // reset lastQueryError that can be overridden by the stateUpdate
+      ...stateUpdate,
+      isLoading: false,
+      items: isFirstPage
+        ? stateUpdate.items
+        : [...(this.items ?? []), ...(stateUpdate.items ?? [])],
+    };
+  }
+
+  async executeQuery(newSearchString?: string) {
+    if (!this.canExecuteQuery(newSearchString)) return;
+    const hasNewSearchQuery = typeof newSearchString !== 'undefined';
+    const searchString = newSearchString ?? this.searchQuery;
+
+    if (hasNewSearchQuery) {
+      this.state.next(this.getStateBeforeFirstQuery(newSearchString ?? ''));
+    } else {
+      this.state.partialNext({ isLoading: true });
+    }
+
+    const 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;
+      }
+
+      stateUpdate.items = await 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();
+  }
+
+  resetState() {
+    this.state.next(this.initialState);
+  }
+
+  resetStateAndActivate() {
+    this.resetState();
+    this.activate();
+  }
+}

package/src/common/ConnectionIdManager.ts

@@ -0,0 +1,51 @@
+export class ConnectionIdManager {
+  loadConnectionIdPromise: Promise<string> | undefined;
+  connectionId?: string;
+  private resolve?: (connectionId: string) => void;
+  private reject?: (reason: any) => void;
+
+  reset = () => {
+    this.loadConnectionIdPromise = undefined;
+    this.resolve = undefined;
+    this.reject = undefined;
+    this.connectionId = undefined;
+  };
+
+  resetConnectionIdPromise = () => {
+    this.connectionId = undefined;
+    this.loadConnectionIdPromise = new Promise<string>((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  };
+
+  resolveConnectionidPromise = (connectionId: string) => {
+    this.connectionId = connectionId;
+    this.resolve?.(connectionId);
+    this.loadConnectionIdPromise = undefined;
+    this.resolve = undefined;
+    this.reject = undefined;
+  };
+
+  rejectConnectionIdPromise = (reason: any) => {
+    this.connectionId = undefined;
+    this.reject?.(reason);
+    this.loadConnectionIdPromise = undefined;
+    this.resolve = undefined;
+    this.reject = undefined;
+  };
+
+  getConnectionId = () => {
+    if (this.connectionId) {
+      return this.connectionId;
+    }
+
+    if (this.loadConnectionIdPromise) {
+      return this.loadConnectionIdPromise;
+    }
+
+    throw new Error(
+      `No connection id was provided when trying to query with presence/watch. You should call "connectUser" to get a WebSocket connection id`,
+    );
+  };
+}

package/src/common/EventDispatcher.ts

@@ -0,0 +1,52 @@
+import { FeedsEvent } from '../types';
+import { LogLevel } from './types';
+
+export class EventDispatcher<
+  Type extends string = FeedsEvent['type'],
+  Event extends { type: string } = FeedsEvent,
+> {
+  private subscribers: Partial<
+    Record<Type | 'all', Array<(event: Event) => void> | undefined>
+  > = {};
+
+  private readonly logger = (level: LogLevel, message: string, extra: any) => {
+    // TODO implement logging
+    console.log(level, message, extra);
+  };
+
+  dispatch = (event: Event) => {
+    const listeners = [
+      ...(this.subscribers[event.type as Type] ?? []),
+      ...(this.subscribers.all ?? []),
+    ];
+    for (const fn of listeners) {
+      try {
+        fn(event);
+      } catch (e) {
+        // TODO: do we really want to silence this error?
+        this.logger('warn', 'Listener failed with error', e);
+      }
+    }
+  };
+
+  on = (eventName: Type | 'all', handler: (event: Event) => void) => {
+    (this.subscribers[eventName] ??= []).push(handler);
+    return () => {
+      this.off(eventName, handler);
+    };
+  };
+
+  off = (eventName: Type | 'all', handler: (event: Event) => void) => {
+    this.subscribers[eventName] = (this.subscribers[eventName] ?? []).filter(
+      (f) => f !== handler,
+    );
+  };
+
+  offAll = (eventName?: Type | 'all') => {
+    if (eventName) {
+      this.subscribers[eventName] = [];
+    } else {
+      this.subscribers = {};
+    }
+  };
+}

package/src/common/FeedSearchSource.ts

@@ -0,0 +1,94 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import type { SearchSourceOptions } from './BaseSearchSource';
+
+import { FeedsClient } from '../FeedsClient';
+import { Feed } from '../Feed';
+
+export class FeedSearchSource extends BaseSearchSource<Feed> {
+  readonly type = 'feed' as const;
+  private readonly client: FeedsClient;
+  // messageSearchChannelFilters: ChannelFilters | undefined;
+  // messageSearchFilters: MessageFilters | undefined;
+  // messageSearchSort: SearchMessageSort | undefined;
+  // channelQueryFilters: ChannelFilters | undefined;
+  // channelQuerySort: ChannelSort | undefined;
+  // channelQueryOptions: Omit<ChannelOptions, 'limit' | 'offset'> | undefined;
+
+  constructor(client: FeedsClient, options?: SearchSourceOptions) {
+    super(options);
+    this.client = client;
+  }
+
+  protected async query(searchQuery: string) {
+    const { connectedUser } = this.client.state.getLatestValue();
+    if (!connectedUser) return { items: [] };
+
+    // const channelFilters: ChannelFilters = {
+    //   members: { $in: [this.client.userID] },
+    //   ...this.messageSearchChannelFilters,
+    // } as ChannelFilters;
+
+    // const messageFilters: MessageFilters = {
+    //   text: searchQuery,
+    //   type: 'regular', // FIXME: type: 'reply' resp. do not filter by type and allow to jump to a message in a thread - missing support
+    //   ...this.messageSearchFilters,
+    // } as MessageFilters;
+
+    // const sort: SearchMessageSort = {
+    //   created_at: -1,
+    //   ...this.messageSearchSort,
+    // };
+
+    // const options = {
+    //   limit: this.pageSize,
+    //   next: this.next,
+    //   sort,
+    // } as SearchOptions;
+
+    // const { next, results } = await this.client.search(
+    //   channelFilters,
+    //   messageFilters,
+    //   options,
+    // );
+    // const items = results.map(({ message }) => message);
+
+    // const cids = Array.from(
+    //   items.reduce((acc, message) => {
+    //     if (message.cid && !this.client.activeChannels[message.cid])
+    //       acc.add(message.cid);
+    //     return acc;
+    //   }, new Set<string>()), // keep the cids unique
+    // );
+    // const allChannelsLoadedLocally = cids.length === 0;
+    // if (!allChannelsLoadedLocally) {
+    //   await this.client.queryChannels(
+    //     {
+    //       cid: { $in: cids },
+    //       ...this.channelQueryFilters,
+    //     } as ChannelFilters,
+    //     {
+    //       last_message_at: -1,
+    //       ...this.channelQuerySort,
+    //     },
+    //     this.channelQueryOptions,
+    //   );
+    // }
+
+    const { feeds: items, next } = await this.client.queryFeeds({
+      filter: {
+        group_id: 'user',
+        $or: [
+          { name: { $autocomplete: searchQuery } },
+          { description: { $autocomplete: searchQuery } },
+          { 'created_by.name': { $autocomplete: searchQuery } },
+        ],
+      },
+    });
+
+    return { items, next };
+  }
+
+  protected filterQueryResults(items: Feed[]) {
+    return items;
+  }
+}