stream-chat 9.16.0 → 9.18.0

package/src/client.ts

@@ -1404,7 +1404,11 @@ export class StreamChat {
    * @param {UserResponse} user
    * @param {boolean} hardDelete
    */
-  _deleteUserMessageReference = (user: UserResponse, hardDelete = false) => {
+  _deleteUserMessageReference = (
+    user: UserResponse,
+    hardDelete = false,
+    deletedAt?: LocalMessage['deleted_at'],
+  ) => {
     const refMap = this.state.userChannelReferences[user.id] || {};
 
     for (const channelID in refMap) {
@@ -1413,7 +1417,7 @@ export class StreamChat {
         const state = channel.state;
 
         /** deleted the messages from this user. */
-        state?.deleteUserMessages(user, hardDelete);
+        state?.deleteUserMessages(user, hardDelete, deletedAt);
       }
     }
   };
@@ -1478,7 +1482,11 @@ export class StreamChat {
       event.user.deleted_at &&
       (event.mark_messages_deleted || event.hard_delete)
     ) {
-      this._deleteUserMessageReference(event.user, event.hard_delete);
+      this._deleteUserMessageReference(
+        event.user,
+        event.hard_delete,
+        event.user.deleted_at ? new Date(event.user.deleted_at) : null,
+      );
     }
   };
 
@@ -1503,6 +1511,14 @@ export class StreamChat {
       this._handleUserEvent(event);
     }
 
+    if (event.type === 'user.messages.deleted' && !event.cid && event.user) {
+      this._deleteUserMessageReference(
+        event.user,
+        event.hard_delete,
+        event.created_at ? new Date(event.created_at) : null,
+      );
+    }
+
     if (event.type === 'health.check' && event.me) {
       client.user = event.me;
       client.state.updateUser(event.me);

package/src/events.ts

@@ -45,6 +45,7 @@ export const EVENT_MAP = {
   'typing.stop': true,
   'user.banned': true,
   'user.deleted': true,
+  'user.messages.deleted': true,
   'user.presence.changed': true,
   'user.unbanned': true,
   'user.unread_message_reminder': true,

package/src/moderation.ts

@@ -7,11 +7,16 @@ import type {
   ModerationConfig,
   ModerationFlagOptions,
   ModerationMuteOptions,
+  ModerationRule,
+  ModerationRuleRequest,
   MuteUserResponse,
   Pager,
   QueryConfigsResponse,
   QueryModerationConfigsFilters,
   QueryModerationConfigsSort,
+  QueryModerationRulesFilters,
+  QueryModerationRulesResponse,
+  QueryModerationRulesSort,
   RequireAtLeastOne,
   ReviewQueueFilters,
   ReviewQueueItem,
@@ -20,6 +25,7 @@ import type {
   ReviewQueueSort,
   SubmitActionOptions,
   UpsertConfigResponse,
+  UpsertModerationRuleResponse,
 } from './types';
 import type { StreamChat } from './client';
 import { normalizeQuerySort } from './utils';
@@ -388,4 +394,60 @@ export class Moderation {
       flags,
     );
   }
+
+  /**
+   * Create or update a moderation rule
+   * @param {ModerationRuleRequest} rule Rule configuration to be upserted
+   * @returns
+   */
+  async upsertModerationRule(rule: ModerationRuleRequest) {
+    return await this.client.post<UpsertModerationRuleResponse>(
+      this.client.baseURL + '/api/v2/moderation/moderation_rule',
+      rule,
+    );
+  }
+
+  /**
+   * Query moderation rules
+   * @param {QueryModerationRulesFilters} filterConditions Filter conditions for querying moderation rules
+   * @param {QueryModerationRulesSort} sort Sort conditions for querying moderation rules
+   * @param {Pager} options Pagination options for querying moderation rules
+   * @returns
+   */
+  async queryModerationRules(
+    filterConditions: QueryModerationRulesFilters = {},
+    sort: QueryModerationRulesSort = [],
+    options: Pager = {},
+  ) {
+    return await this.client.post<QueryModerationRulesResponse>(
+      this.client.baseURL + '/api/v2/moderation/moderation_rules',
+      {
+        filter: filterConditions,
+        sort,
+        ...options,
+      },
+    );
+  }
+
+  /**
+   * Get a specific moderation rule by ID
+   * @param {string} id ID of the moderation rule to fetch
+   * @returns
+   */
+  async getModerationRule(id: string) {
+    return await this.client.get<{ rule: ModerationRule }>(
+      this.client.baseURL + '/api/v2/moderation/moderation_rule/' + id,
+    );
+  }
+
+  /**
+   * Delete a moderation rule by ID
+   * @param {string} id ID of the moderation rule to delete
+   * @returns
+   */
+  async deleteModerationRule(id: string) {
+    return await this.client.delete(
+      this.client.baseURL + '/api/v2/moderation/moderation_rule/' + id,
+    );
+  }
 }

package/src/pagination/FilterBuilder.ts

@@ -0,0 +1,104 @@
+import { StateStore } from '../store';
+import type { ArrayOneOrMore, ArrayTwoOrMore, QueryFilter } from '../types';
+
+type ElementType<T> = T extends (infer U)[] ? U : T;
+
+// redeclared because QueryFilter does not account for the additional operators
+export type ExtendedQueryFilter<T = string> = QueryFilter<T> & {
+  $autocomplete?: T extends string ? string : never;
+  $contains?: ElementType<T>;
+  $in?: ElementType<T>[];
+  $q?: T extends string ? string : never;
+};
+
+export type ExtendedQueryLogicalOperators<T> = {
+  $and?: ArrayOneOrMore<ExtendedQueryFilters<T>>;
+  $nor?: ArrayOneOrMore<ExtendedQueryFilters<T>>;
+  $or?: ArrayTwoOrMore<ExtendedQueryFilters<T>>;
+};
+
+export type ExtendedQueryFilters<T> = {
+  [K in keyof T]?: ExtendedQueryFilter<T[K]>;
+} & ExtendedQueryLogicalOperators<T>;
+
+export type FilterBuilderGenerators<
+  TFilters,
+  TContext extends Record<string, unknown> = {},
+> = {
+  [K in string]: {
+    enabled: boolean;
+    generate: (context: TContext) => Partial<TFilters> | null;
+  };
+};
+
+export type FilterBuilderOptions<TFilters, TContext extends Record<string, unknown>> = {
+  initialFilterConfig?: FilterBuilderGenerators<TFilters, TContext>;
+  initialContext?: TContext;
+};
+
+export class FilterBuilder<TFilters, TContext extends Record<string, unknown> = {}> {
+  filterConfig: StateStore<FilterBuilderGenerators<TFilters, TContext>>;
+  context: StateStore<TContext>;
+
+  constructor(params?: FilterBuilderOptions<TFilters, TContext>) {
+    this.context = new StateStore(params?.initialContext ?? ({} as TContext));
+    this.filterConfig = new StateStore(
+      params?.initialFilterConfig ?? ({} as FilterBuilderGenerators<TFilters, TContext>),
+    );
+  }
+
+  updateFilterConfig(config: Partial<FilterBuilderGenerators<TFilters, TContext>>) {
+    this.filterConfig.partialNext(config);
+  }
+
+  enableFilter(filterKey: keyof FilterBuilderGenerators<TFilters, TContext>) {
+    const config = this.filterConfig.getLatestValue();
+    if (config[filterKey]) {
+      this.filterConfig.partialNext({
+        [filterKey]: {
+          ...config[filterKey],
+          enabled: true,
+        },
+      });
+    }
+  }
+
+  disableFilter(filterKey: keyof FilterBuilderGenerators<TFilters, TContext>) {
+    const config = this.filterConfig.getLatestValue();
+    if (config[filterKey]) {
+      this.filterConfig.partialNext({
+        [filterKey]: {
+          ...config[filterKey],
+          enabled: false,
+        },
+      });
+    }
+  }
+
+  updateContext(newContext: Partial<TContext>) {
+    this.context.partialNext(newContext);
+  }
+
+  buildFilters(params?: {
+    context?: Partial<TContext>;
+    baseFilters?: Partial<TFilters>;
+  }): Partial<TFilters> {
+    const filters: Partial<TFilters> = {
+      ...(params?.baseFilters ?? {}),
+    } as Partial<TFilters>;
+
+    const filterConfig = this.filterConfig.getLatestValue();
+    for (const key in filterConfig) {
+      const configItem = filterConfig[key];
+      if (!configItem?.enabled) continue;
+
+      const generated = configItem.generate({
+        ...this.context.getLatestValue(),
+        ...(params?.context ?? {}),
+      });
+      if (generated) Object.assign(filters, generated);
+    }
+
+    return filters;
+  }
+}

package/src/pagination/index.ts

@@ -1,2 +1,3 @@
 export * from './BasePaginator';
+export * from './FilterBuilder';
 export * from './ReminderPaginator';

package/src/search/BaseSearchSource.ts

@@ -59,7 +59,7 @@ const DEFAULT_SEARCH_SOURCE_OPTIONS: Required<SearchSourceOptions> = {
 
 abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
   state: StateStore<SearchSourceState<T>>;
-  protected pageSize: number;
+  pageSize: number;
   abstract readonly type: SearchSourceType;
 
   protected constructor(options?: SearchSourceOptions) {

package/src/search/ChannelSearchSource.ts

@@ -1,27 +1,66 @@
 import { BaseSearchSource } from './BaseSearchSource';
+import type { FilterBuilderOptions } from '../pagination';
+import { FilterBuilder } from '../pagination';
 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> {
+type CustomContext = Record<string, unknown>;
+
+export type ChannelSearchSourceFilterBuilderContext<
+  C extends CustomContext = CustomContext,
+> = { searchQuery?: string } & C;
+
+export class ChannelSearchSource<
+  TFilterContext extends CustomContext = CustomContext,
+> extends BaseSearchSource<Channel> {
   readonly type = 'channels';
-  private client: StreamChat;
+  client: StreamChat;
   filters: ChannelFilters | undefined;
   sort: ChannelSort | undefined;
   searchOptions: Omit<ChannelOptions, 'limit' | 'offset'> | undefined;
+  filterBuilder: FilterBuilder<
+    ChannelFilters,
+    ChannelSearchSourceFilterBuilderContext<TFilterContext>
+  >;
 
-  constructor(client: StreamChat, options?: SearchSourceOptions) {
+  constructor(
+    client: StreamChat,
+    options?: SearchSourceOptions,
+    filterBuilderOptions: FilterBuilderOptions<
+      ChannelFilters,
+      ChannelSearchSourceFilterBuilderContext<TFilterContext>
+    > = {},
+  ) {
     super(options);
     this.client = client;
+    this.filterBuilder = new FilterBuilder<
+      ChannelFilters,
+      ChannelSearchSourceFilterBuilderContext<TFilterContext>
+    >({
+      ...filterBuilderOptions,
+      initialFilterConfig: {
+        name: {
+          enabled: true,
+          generate: ({ searchQuery }) =>
+            searchQuery ? { name: { $autocomplete: searchQuery } } : null,
+        },
+        ...filterBuilderOptions.initialFilterConfig,
+      },
+    });
   }
 
   protected async query(searchQuery: string) {
-    const filters = {
-      members: { $in: [this.client.userID] },
-      name: { $autocomplete: searchQuery },
-      ...this.filters,
-    } as ChannelFilters;
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: {
+        ...(this.client.userID ? { members: { $in: [this.client.userID] } } : {}),
+        ...this.filters,
+      },
+      context: { searchQuery } as Partial<
+        ChannelSearchSourceFilterBuilderContext<TFilterContext>
+      >,
+    });
     const sort = this.sort ?? {};
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
     const items = await this.client.queryChannels(filters, sort, options);

package/src/search/MessageSearchSource.ts

@@ -10,46 +10,161 @@ import type {
 } from '../types';
 import type { StreamChat } from '../client';
 import type { SearchSourceOptions } from './types';
+import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
 
-export class MessageSearchSource extends BaseSearchSource<MessageResponse> {
+type CustomContext = Record<string, unknown>;
+
+// Built-in contexts per builder
+type BuiltInContexts = {
+  messageSearchChannel: { searchQuery?: string };
+  messageSearch: { searchQuery?: string };
+  channelQuery: { cids?: string[] };
+};
+
+// Merge Built-in with user-provided Custom context
+type MergeContext<
+  B extends Record<string, unknown>,
+  C extends CustomContext | undefined,
+> = B & (C extends object ? C : {});
+
+// User can provide custom context for each builder
+type MessageSearchSourceContexts = Partial<{
+  messageSearchChannelContext: Record<string, unknown>;
+  messageSearchContext: Record<string, unknown>;
+  channelQueryContext: Record<string, unknown>;
+}>;
+
+export type MessageSearchSourceFilterBuilderOptions<
+  TContexts extends MessageSearchSourceContexts = {},
+> = Partial<{
+  messageSearchChannel: FilterBuilderOptions<
+    ChannelFilters,
+    MergeContext<
+      BuiltInContexts['messageSearchChannel'],
+      TContexts['messageSearchChannelContext']
+    >
+  >;
+  messageSearch: FilterBuilderOptions<
+    MessageFilters,
+    MergeContext<BuiltInContexts['messageSearch'], TContexts['messageSearchContext']>
+  >;
+  channelQuery: FilterBuilderOptions<
+    ChannelFilters,
+    MergeContext<BuiltInContexts['channelQuery'], TContexts['channelQueryContext']>
+  >;
+}>;
+
+export class MessageSearchSource<
+  TContexts extends MessageSearchSourceContexts = {},
+> extends BaseSearchSource<MessageResponse> {
   readonly type = 'messages';
   private client: StreamChat;
+
   messageSearchChannelFilters: ChannelFilters | undefined;
   messageSearchFilters: MessageFilters | undefined;
   messageSearchSort: SearchMessageSort | undefined;
+
   channelQueryFilters: ChannelFilters | undefined;
   channelQuerySort: ChannelSort | undefined;
   channelQueryOptions: Omit<ChannelOptions, 'limit' | 'offset'> | undefined;
 
-  constructor(client: StreamChat, options?: SearchSourceOptions) {
+  messageSearchChannelFilterBuilder: FilterBuilder<
+    ChannelFilters,
+    MergeContext<
+      BuiltInContexts['messageSearchChannel'],
+      TContexts['messageSearchChannelContext']
+    >
+  >;
+  messageSearchFilterBuilder: FilterBuilder<
+    MessageFilters,
+    MergeContext<BuiltInContexts['messageSearch'], TContexts['messageSearchContext']>
+  >;
+  channelQueryFilterBuilder: FilterBuilder<
+    ChannelFilters,
+    MergeContext<BuiltInContexts['channelQuery'], TContexts['channelQueryContext']>
+  >;
+
+  constructor(
+    client: StreamChat,
+    options?: SearchSourceOptions,
+    filterBuilderOptions?: MessageSearchSourceFilterBuilderOptions<TContexts>,
+  ) {
     super(options);
     this.client = client;
+
+    this.messageSearchChannelFilterBuilder = new FilterBuilder<
+      ChannelFilters,
+      MergeContext<
+        BuiltInContexts['messageSearchChannel'],
+        TContexts['messageSearchChannelContext']
+      >
+    >(filterBuilderOptions?.messageSearchChannel);
+
+    this.messageSearchFilterBuilder = new FilterBuilder<
+      MessageFilters,
+      MergeContext<BuiltInContexts['messageSearch'], TContexts['messageSearchContext']>
+    >({
+      ...filterBuilderOptions?.messageSearch,
+      initialFilterConfig: {
+        text: {
+          enabled: true,
+          generate: ({ searchQuery }) => (searchQuery ? { text: searchQuery } : null),
+        },
+        ...filterBuilderOptions?.messageSearch?.initialFilterConfig,
+      },
+    });
+
+    this.channelQueryFilterBuilder = new FilterBuilder<
+      ChannelFilters,
+      MergeContext<BuiltInContexts['channelQuery'], TContexts['channelQueryContext']>
+    >({
+      ...filterBuilderOptions?.channelQuery,
+      initialFilterConfig: {
+        cid: {
+          enabled: true,
+          generate: ({ cids }) => (cids ? { cid: { $in: cids } } : null),
+        },
+        ...filterBuilderOptions?.channelQuery?.initialFilterConfig,
+      },
+    });
   }
 
   protected async query(searchQuery: string) {
-    if (!this.client.userID) return { items: [] };
+    if (!this.client.userID || !searchQuery || this.next === null) return { items: [] };
 
-    const channelFilters: ChannelFilters = {
-      members: { $in: [this.client.userID] },
-      ...this.messageSearchChannelFilters,
-    } as ChannelFilters;
+    const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
+      baseFilters: {
+        ...(this.client.userID ? { members: { $in: [this.client.userID] } } : {}),
+        ...this.messageSearchChannelFilters,
+      },
+      context: { searchQuery } as Partial<
+        MergeContext<
+          BuiltInContexts['messageSearchChannel'],
+          TContexts['messageSearchChannelContext']
+        >
+      >,
+    });
 
-    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 messageFilters: MessageFilters = this.messageSearchFilterBuilder.buildFilters({
+      baseFilters: {
+        type: 'regular',
+        ...this.messageSearchFilters,
+      },
+      context: { searchQuery } as Partial<
+        MergeContext<BuiltInContexts['messageSearch'], TContexts['messageSearchContext']>
+      >,
+    });
 
     const sort: SearchMessageSort = {
       created_at: -1,
       ...this.messageSearchSort,
     };
 
-    const options = {
+    const options: SearchOptions = {
       limit: this.pageSize,
       next: this.next,
       sort,
-    } as SearchOptions;
+    };
 
     const { next, results } = await this.client.search(
       channelFilters,
@@ -62,15 +177,18 @@ export class MessageSearchSource extends BaseSearchSource<MessageResponse> {
       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
+      }, new Set<string>()),
     );
-    const allChannelsLoadedLocally = cids.length === 0;
-    if (!allChannelsLoadedLocally) {
+
+    if (cids.length > 0) {
+      const channelQueryFilters = this.channelQueryFilterBuilder.buildFilters({
+        baseFilters: this.channelQueryFilters,
+        context: { cids } as Partial<
+          MergeContext<BuiltInContexts['channelQuery'], TContexts['channelQueryContext']>
+        >,
+      });
       await this.client.queryChannels(
-        {
-          cid: { $in: cids },
-          ...this.channelQueryFilters,
-        } as ChannelFilters,
+        channelQueryFilters,
         {
           last_message_at: -1,
           ...this.channelQuerySort,

package/src/search/UserSearchSource.ts

@@ -1,28 +1,65 @@
 import { BaseSearchSource } from './BaseSearchSource';
+import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
 import type { StreamChat } from '../client';
 import type { UserFilters, UserOptions, UserResponse, UserSort } from '../types';
 import type { SearchSourceOptions } from './types';
 
-export class UserSearchSource extends BaseSearchSource<UserResponse> {
+type CustomContext = Record<string, unknown>;
+
+export type UserSearchSourceFilterBuilderContext<
+  C extends CustomContext = CustomContext,
+> = { searchQuery?: string } & C;
+
+export class UserSearchSource<
+  TFilterContext extends CustomContext = CustomContext,
+> extends BaseSearchSource<UserResponse> {
   readonly type = 'users';
-  private client: StreamChat;
+  client: StreamChat;
   filters: UserFilters | undefined;
   sort: UserSort | undefined;
   searchOptions: Omit<UserOptions, 'limit' | 'offset'> | undefined;
+  filterBuilder: FilterBuilder<
+    UserFilters,
+    UserSearchSourceFilterBuilderContext<TFilterContext>
+  >;
 
-  constructor(client: StreamChat, options?: SearchSourceOptions) {
+  constructor(
+    client: StreamChat,
+    options?: SearchSourceOptions,
+    filterBuilderOptions: FilterBuilderOptions<
+      UserFilters,
+      UserSearchSourceFilterBuilderContext<TFilterContext>
+    > = {},
+  ) {
     super(options);
     this.client = client;
+    this.filterBuilder = new FilterBuilder<
+      UserFilters,
+      UserSearchSourceFilterBuilderContext<TFilterContext>
+    >({
+      initialFilterConfig: {
+        $or: {
+          enabled: true,
+          generate: ({ searchQuery }) =>
+            searchQuery
+              ? {
+                  $or: [
+                    { id: { $autocomplete: searchQuery } },
+                    { name: { $autocomplete: searchQuery } },
+                  ],
+                }
+              : null,
+        },
+      },
+      ...filterBuilderOptions,
+    });
   }
 
   protected async query(searchQuery: string) {
-    const filters = {
-      $or: [
-        { id: { $autocomplete: searchQuery } },
-        { name: { $autocomplete: searchQuery } },
-      ],
-      ...this.filters,
-    } as UserFilters;
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: this.filters,
+      context: { searchQuery } as UserSearchSourceFilterBuilderContext<TFilterContext>,
+    });
     const sort = { id: 1, ...this.sort } as UserSort;
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
     const { users } = await this.client.queryUsers(filters, sort, options);

package/src/search/index.ts

@@ -1,6 +1,6 @@
 export * from './BaseSearchSource';
 export * from './SearchController';
-export { UserSearchSource } from './UserSearchSource';
-export { ChannelSearchSource } from './ChannelSearchSource';
-export { MessageSearchSource } from './MessageSearchSource';
+export * from './UserSearchSource';
+export * from './ChannelSearchSource';
+export * from './MessageSearchSource';
 export * from './types';