stream-chat 9.6.1 → 9.8.0

package/src/search/BaseSearchSource.ts

@@ -1,19 +1,21 @@
 import { StateStore } from '../store';
 import { debounce, type DebouncedFunc } from '../utils';
+import type {
+  QueryReturnValue,
+  SearchSourceOptions,
+  SearchSourceState,
+  SearchSourceType,
+} from './types';
 
-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>>;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface SearchSource<T = any> {
+interface ISearchSource<T = any> {
   activate(): void;
 
-  cancelScheduledQuery(): void;
-
   canExecuteQuery(newSearchString?: string): boolean;
 
   deactivate(): void;
@@ -30,48 +32,40 @@ 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;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-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;
-};
+export interface SearchSource<T = any> extends ISearchSource<T> {
+  cancelScheduledQuery(): void;
+  setDebounceOptions(options: DebounceOptions): void;
+  search(text?: string): Promise<void> | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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,
 } as const;
 
-export abstract class BaseSearchSource<T> implements SearchSource<T> {
+abstract class BaseSearchSourceBase<T> implements ISearchSource<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 };
+    const { pageSize } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
     this.pageSize = pageSize;
     this.state = new StateStore<SearchSourceState<T>>(this.initialState);
-    this.setDebounceOptions({ debounceMs });
   }
 
   get lastQueryError() {
@@ -123,14 +117,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 });
@@ -177,8 +163,7 @@ export abstract class BaseSearchSource<T> implements SearchSource<T> {
     };
   }
 
-  async executeQuery(newSearchString?: string) {
-    if (!this.canExecuteQuery(newSearchString)) return;
+  protected prepareStateForQuery(newSearchString?: string) {
     const hasNewSearchQuery = typeof newSearchString !== 'undefined';
     const searchString = newSearchString ?? this.searchQuery;
 
@@ -188,20 +173,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 (next || 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;
@@ -215,13 +247,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/search/ChannelSearchSource.ts

@@ -1,8 +1,8 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { SearchSourceOptions } from './BaseSearchSource';
 import type { Channel } from '../channel';
 import type { StreamChat } from '../client';
 import type { ChannelFilters, ChannelOptions, ChannelSort } from '../types';
+import type { SearchSourceOptions } from './types';
 
 export class ChannelSearchSource extends BaseSearchSource<Channel> {
   readonly type = 'channels';

package/src/search/MessageSearchSource.ts

@@ -1,5 +1,4 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { SearchSourceOptions } from './BaseSearchSource';
 import type {
   ChannelFilters,
   ChannelOptions,
@@ -10,6 +9,7 @@ import type {
   SearchOptions,
 } from '../types';
 import type { StreamChat } from '../client';
+import type { SearchSourceOptions } from './types';
 
 export class MessageSearchSource extends BaseSearchSource<MessageResponse> {
   readonly type = 'messages';

package/src/search/UserSearchSource.ts

@@ -1,7 +1,7 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { SearchSourceOptions } from './BaseSearchSource';
 import type { StreamChat } from '../client';
 import type { UserFilters, UserOptions, UserResponse, UserSort } from '../types';
+import type { SearchSourceOptions } from './types';
 
 export class UserSearchSource extends BaseSearchSource<UserResponse> {
   readonly type = 'users';

package/src/search/index.ts

@@ -3,3 +3,4 @@ export * from './SearchController';
 export { UserSearchSource } from './UserSearchSource';
 export { ChannelSearchSource } from './ChannelSearchSource';
 export { MessageSearchSource } from './MessageSearchSource';
+export * from './types';

package/src/search/types.ts

@@ -0,0 +1,20 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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;
+};
+
+export type SearchSourceType = 'channels' | 'users' | 'messages' | (string & {});
+export type QueryReturnValue<T> = { items: T[]; next?: string | null };

package/src/types.ts

@@ -4036,7 +4036,7 @@ export type ReminderAPIResponse = APIResponse & {
 
 export type CreateReminderOptions = {
   messageId: string;
-  remind_at?: string;
+  remind_at?: string | null;
   user_id?: string;
 };
 
@@ -4099,7 +4099,7 @@ export type QueryRemindersResponse = {
   next?: string;
 };
 
-export type HookType = 'webhook' | 'sqs' | 'sns';
+export type HookType = 'webhook' | 'sqs' | 'sns' | 'pending_message';
 
 export type EventHook = {
   id?: string;
@@ -4119,6 +4119,13 @@ export type EventHook = {
   sns_key?: string;
   sns_secret?: string;
   sns_role_arn?: string;
+
+  // pending message config
+  timeout_ms?: number;
+  callback?: {
+    mode: 'CALLBACK_MODE_NONE' | 'CALLBACK_MODE_REST' | 'CALLBACK_MODE_TWIRP';
+  };
+
   created_at?: string;
   updated_at?: string;
 };

package/src/utils.ts

@@ -297,9 +297,9 @@ export const axiosParamsSerializer: AxiosRequestConfig['paramsSerializer'] = (pa
 
 /**
  * Takes the message object, parses the dates, sets `__html`
- * and sets the status to `received` if missing; returns a new message object.
+ * and sets the status to `received` if missing; returns a new LocalMessage object.
  *
- * @param {MessageResponse} message `MessageResponse` object
+ * @param {LocalMessage} message `LocalMessage` object
  */
 export function formatMessage(
   message: MessageResponse | MessageResponseBase | LocalMessage,
@@ -330,6 +330,35 @@ export function formatMessage(
   } as LocalMessage;
 }
 
+/**
+ * @private
+ *
+ * Takes a LocalMessage, parses the dates back to strings,
+ * and converts the message back to a MessageResponse.
+ *
+ * @param {MessageResponse} message `MessageResponse` object
+ */
+export function unformatMessage(message: LocalMessage): MessageResponse {
+  const toMessageResponseBase = (
+    msg: LocalMessage | null | undefined,
+  ): MessageResponseBase | null => {
+    if (!msg) return null;
+    const newDateString = new Date().toISOString();
+    return {
+      ...msg,
+      created_at: message.created_at ? message.created_at.toISOString() : newDateString,
+      deleted_at: message.deleted_at ? message.deleted_at.toISOString() : undefined,
+      pinned_at: message.pinned_at ? message.pinned_at.toISOString() : undefined,
+      updated_at: message.updated_at ? message.updated_at.toISOString() : newDateString,
+    };
+  };
+
+  return {
+    ...toMessageResponseBase(message),
+    quoted_message: toMessageResponseBase((message as LocalMessage).quoted_message),
+  } as MessageResponse;
+}
+
 export const localMessageToNewMessagePayload = (localMessage: LocalMessage): Message => {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   const {