stream-chat 9.15.0 → 9.17.0

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';

package/src/types.ts

@@ -287,6 +287,7 @@ export type ChannelResponse = CustomChannelData & {
   last_message_at?: string;
   member_count?: number;
   members?: ChannelMemberResponse[];
+  message_count?: number;
   muted?: boolean;
   mute_expires_at?: string;
   own_capabilities?: string[];
@@ -1445,6 +1446,8 @@ export type Event = CustomEventData & {
   ai_message?: string;
   ai_state?: AIState;
   channel?: ChannelResponse;
+  channel_custom?: CustomChannelData;
+  channel_member_count?: number;
   channel_id?: string;
   channel_type?: string;
   cid?: string;
@@ -2365,6 +2368,7 @@ export type ChannelConfigFields = {
   replies?: boolean;
   search?: boolean;
   shared_locations?: boolean;
+  count_messages?: boolean; // Feature flag for message count
   typing_events?: boolean;
   uploads?: boolean;
   url_enrichment?: boolean;

package/src/utils.ts

@@ -416,6 +416,81 @@ export const toUpdatedMessagePayload = (
   };
 };
 
+export const toDeletedMessage = ({
+  message,
+  deletedAt,
+  hardDelete = false,
+}: {
+  message: LocalMessage | LocalMessageBase;
+  deletedAt: LocalMessage['deleted_at'];
+  hardDelete: boolean;
+}) => {
+  if (hardDelete) {
+    /**
+     * In case of hard delete, we need to strip down all text, html, attachments and all the custom properties on message
+     * The hard-deleted message is kept in the UI until the messages are re-queried
+     * FIXME: we are returning an object that does not match LocalMessage | LocalMessageBase
+     */
+    return {
+      attachments: [],
+      cid: message.cid,
+      created_at: message.created_at,
+      deleted_at: deletedAt,
+      id: message.id,
+      latest_reactions: [],
+      mentioned_users: [],
+      own_reactions: [],
+      parent_id: message.parent_id,
+      reply_count: message.reply_count,
+      status: message.status,
+      thread_participants: message.thread_participants,
+      type: 'deleted' as const,
+      updated_at: message.updated_at,
+      user: message.user,
+    };
+  } else {
+    return {
+      ...message,
+      attachments: [],
+      type: 'deleted',
+      deleted_at: deletedAt,
+    };
+  }
+};
+
+export const deleteUserMessages = ({
+  messages,
+  user,
+  hardDelete = false,
+  deletedAt,
+}: {
+  messages: Array<LocalMessage>;
+  user: UserResponse;
+  hardDelete: boolean;
+  deletedAt: LocalMessage['deleted_at'];
+}) => {
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.user?.id === user.id) {
+      messages[i] =
+        message.type === 'deleted'
+          ? message
+          : (toDeletedMessage({ message, hardDelete, deletedAt }) as LocalMessage);
+    }
+
+    if (message.quoted_message?.user?.id === user.id) {
+      messages[i].quoted_message =
+        message.quoted_message.type === 'deleted'
+          ? message.quoted_message
+          : (toDeletedMessage({
+              message: messages[i].quoted_message as LocalMessageBase,
+              hardDelete,
+              deletedAt,
+            }) as LocalMessage);
+    }
+  }
+};
+
 export const findIndexInSortedArray = <T, L>({
   needle,
   sortedArray,