stream-chat 9.15.0 → 9.17.0

package/dist/cjs/index.node.cjs

@@ -11877,6 +11877,7 @@ __export(index_exports, {
   DevToken: () => DevToken,
   EVENT_MAP: () => EVENT_MAP,
   ErrorFromResponse: () => ErrorFromResponse,
+  FilterBuilder: () => FilterBuilder,
   FixedSizeQueueCache: () => FixedSizeQueueCache,
   InsightMetrics: () => InsightMetrics,
   JWTServerToken: () => JWTServerToken,
@@ -15357,6 +15358,58 @@ var toUpdatedMessagePayload = (message) => {
     )
   };
 };
+var toDeletedMessage = ({
+  message,
+  deletedAt,
+  hardDelete = false
+}) => {
+  if (hardDelete) {
+    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",
+      updated_at: message.updated_at,
+      user: message.user
+    };
+  } else {
+    return {
+      ...message,
+      attachments: [],
+      type: "deleted",
+      deleted_at: deletedAt
+    };
+  }
+};
+var deleteUserMessages = ({
+  messages,
+  user,
+  hardDelete = false,
+  deletedAt
+}) => {
+  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 });
+    }
+    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,
+        hardDelete,
+        deletedAt
+      });
+    }
+  }
+};
 var findIndexInSortedArray = ({
   needle,
   sortedArray,
@@ -15891,46 +15944,24 @@ var ChannelState = class {
      * @param {UserResponse} user
      * @param {boolean} hardDelete
      */
-    this.deleteUserMessages = (user, hardDelete = false) => {
-      const _deleteUserMessages = (messages, user2, hardDelete2 = false) => {
-        for (let i = 0; i < messages.length; i++) {
-          const m = messages[i];
-          if (m.user?.id !== user2.id) {
-            continue;
-          }
-          if (hardDelete2) {
-            messages[i] = {
-              cid: m.cid,
-              created_at: m.created_at,
-              deleted_at: user2.deleted_at,
-              id: m.id,
-              latest_reactions: [],
-              mentioned_users: [],
-              own_reactions: [],
-              parent_id: m.parent_id,
-              reply_count: m.reply_count,
-              status: m.status,
-              thread_participants: m.thread_participants,
-              type: "deleted",
-              updated_at: m.updated_at,
-              user: m.user
-            };
-          } else {
-            messages[i] = {
-              ...m,
-              type: "deleted",
-              deleted_at: user2.deleted_at ? new Date(user2.deleted_at) : null
-            };
-          }
-        }
-      };
+    this.deleteUserMessages = (user, hardDelete = false, deletedAt) => {
       this.messageSets.forEach(
-        (set) => _deleteUserMessages(set.messages, user, hardDelete)
+        ({ messages }) => deleteUserMessages({ messages, user, hardDelete, deletedAt: deletedAt ?? null })
       );
       for (const parentId in this.threads) {
-        _deleteUserMessages(this.threads[parentId], user, hardDelete);
+        deleteUserMessages({
+          messages: this.threads[parentId],
+          user,
+          hardDelete,
+          deletedAt: deletedAt ?? null
+        });
       }
-      _deleteUserMessages(this.pinnedMessages, user, hardDelete);
+      deleteUserMessages({
+        messages: this.pinnedMessages,
+        user,
+        hardDelete,
+        deletedAt: deletedAt ?? null
+      });
     };
     this._channel = channel;
     this.watcher_count = 0;
@@ -19521,21 +19552,242 @@ var SearchController = class {
   }
 };
 
+// src/pagination/BasePaginator.ts
+var DEFAULT_PAGINATION_OPTIONS = {
+  debounceMs: 300,
+  pageSize: 10
+};
+var BasePaginator = class {
+  constructor(options) {
+    this._isCursorPagination = false;
+    this.setDebounceOptions = ({ debounceMs }) => {
+      this._executeQueryDebounced = debounce(this.executeQuery.bind(this), debounceMs);
+    };
+    this.canExecuteQuery = (direction) => !this.isLoading && direction === "next" && this.hasNext || direction === "prev" && this.hasPrev;
+    this.next = () => this.executeQuery({ direction: "next" });
+    this.prev = () => this.executeQuery({ direction: "prev" });
+    this.nextDebounced = () => {
+      this._executeQueryDebounced({ direction: "next" });
+    };
+    this.prevDebounced = () => {
+      this._executeQueryDebounced({ direction: "prev" });
+    };
+    const { debounceMs, pageSize } = { ...DEFAULT_PAGINATION_OPTIONS, ...options };
+    this.pageSize = pageSize;
+    this.state = new StateStore(this.initialState);
+    this.setDebounceOptions({ debounceMs });
+  }
+  get lastQueryError() {
+    return this.state.getLatestValue().lastQueryError;
+  }
+  get hasNext() {
+    return this.state.getLatestValue().hasNext;
+  }
+  get hasPrev() {
+    return this.state.getLatestValue().hasPrev;
+  }
+  get hasResults() {
+    return Array.isArray(this.state.getLatestValue().items);
+  }
+  get isLoading() {
+    return this.state.getLatestValue().isLoading;
+  }
+  get initialState() {
+    return {
+      hasNext: true,
+      hasPrev: true,
+      //todo: check if optimistic value does not cause problems in UI
+      isLoading: false,
+      items: void 0,
+      lastQueryError: void 0,
+      cursor: void 0,
+      offset: 0
+    };
+  }
+  get items() {
+    return this.state.getLatestValue().items;
+  }
+  get cursor() {
+    return this.state.getLatestValue().cursor;
+  }
+  get offset() {
+    return this.state.getLatestValue().offset;
+  }
+  getStateBeforeFirstQuery() {
+    return {
+      ...this.initialState,
+      isLoading: true
+    };
+  }
+  getStateAfterQuery(stateUpdate, isFirstPage) {
+    const current = this.state.getLatestValue();
+    return {
+      ...current,
+      lastQueryError: void 0,
+      // reset lastQueryError that can be overridden by the stateUpdate
+      ...stateUpdate,
+      isLoading: false,
+      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
+    };
+  }
+  async executeQuery({ direction }) {
+    if (!this.canExecuteQuery(direction)) return;
+    const isFirstPage = typeof this.items === "undefined";
+    if (isFirstPage) {
+      this.state.next(this.getStateBeforeFirstQuery());
+    } else {
+      this.state.partialNext({ isLoading: true });
+    }
+    const stateUpdate = {};
+    try {
+      const results = await this.query({ direction });
+      if (!results) return;
+      const { items, next, prev } = results;
+      if (isFirstPage && (next || prev)) {
+        this._isCursorPagination = true;
+      }
+      if (this._isCursorPagination) {
+        stateUpdate.cursor = { next: next || null, prev: prev || null };
+        stateUpdate.hasNext = !!next;
+        stateUpdate.hasPrev = !!prev;
+      } 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;
+    } finally {
+      this.state.next(this.getStateAfterQuery(stateUpdate, isFirstPage));
+    }
+  }
+  cancelScheduledQuery() {
+    this._executeQueryDebounced.cancel();
+  }
+  resetState() {
+    this.state.next(this.initialState);
+  }
+};
+
+// src/pagination/FilterBuilder.ts
+var FilterBuilder = class {
+  constructor(params) {
+    this.context = new StateStore(params?.initialContext ?? {});
+    this.filterConfig = new StateStore(
+      params?.initialFilterConfig ?? {}
+    );
+  }
+  updateFilterConfig(config) {
+    this.filterConfig.partialNext(config);
+  }
+  enableFilter(filterKey) {
+    const config = this.filterConfig.getLatestValue();
+    if (config[filterKey]) {
+      this.filterConfig.partialNext({
+        [filterKey]: {
+          ...config[filterKey],
+          enabled: true
+        }
+      });
+    }
+  }
+  disableFilter(filterKey) {
+    const config = this.filterConfig.getLatestValue();
+    if (config[filterKey]) {
+      this.filterConfig.partialNext({
+        [filterKey]: {
+          ...config[filterKey],
+          enabled: false
+        }
+      });
+    }
+  }
+  updateContext(newContext) {
+    this.context.partialNext(newContext);
+  }
+  buildFilters(params) {
+    const filters = {
+      ...params?.baseFilters ?? {}
+    };
+    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;
+  }
+};
+
+// src/pagination/ReminderPaginator.ts
+var ReminderPaginator = class extends BasePaginator {
+  constructor(client, options) {
+    super(options);
+    this.query = async ({
+      direction
+    }) => {
+      const cursor = this.cursor?.[direction];
+      const {
+        reminders: items,
+        next,
+        prev
+      } = await this.client.queryReminders({
+        filter: this.filters,
+        sort: this.sort,
+        limit: this.pageSize,
+        [direction]: cursor
+      });
+      return { items, next, prev };
+    };
+    this.filterQueryResults = (items) => items;
+    this.client = client;
+  }
+  get filters() {
+    return this._filters;
+  }
+  get sort() {
+    return this._sort;
+  }
+  set filters(filters) {
+    this._filters = filters;
+    this.resetState();
+  }
+  set sort(sort) {
+    this._sort = sort;
+    this.resetState();
+  }
+};
+
 // src/search/UserSearchSource.ts
 var UserSearchSource = class extends BaseSearchSource {
-  constructor(client, options) {
+  constructor(client, options, filterBuilderOptions = {}) {
     super(options);
     this.type = "users";
     this.client = client;
+    this.filterBuilder = new FilterBuilder({
+      initialFilterConfig: {
+        $or: {
+          enabled: true,
+          generate: ({ searchQuery }) => searchQuery ? {
+            $or: [
+              { id: { $autocomplete: searchQuery } },
+              { name: { $autocomplete: searchQuery } }
+            ]
+          } : null
+        }
+      },
+      ...filterBuilderOptions
+    });
   }
   async query(searchQuery) {
-    const filters = {
-      $or: [
-        { id: { $autocomplete: searchQuery } },
-        { name: { $autocomplete: searchQuery } }
-      ],
-      ...this.filters
-    };
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: this.filters,
+      context: { searchQuery }
+    });
     const sort = { id: 1, ...this.sort };
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
     const { users } = await this.client.queryUsers(filters, sort, options);
@@ -19548,17 +19800,29 @@ var UserSearchSource = class extends BaseSearchSource {
 
 // src/search/ChannelSearchSource.ts
 var ChannelSearchSource = class extends BaseSearchSource {
-  constructor(client, options) {
+  constructor(client, options, filterBuilderOptions = {}) {
     super(options);
     this.type = "channels";
     this.client = client;
+    this.filterBuilder = new FilterBuilder({
+      ...filterBuilderOptions,
+      initialFilterConfig: {
+        name: {
+          enabled: true,
+          generate: ({ searchQuery }) => searchQuery ? { name: { $autocomplete: searchQuery } } : null
+        },
+        ...filterBuilderOptions.initialFilterConfig
+      }
+    });
   }
   async query(searchQuery) {
-    const filters = {
-      members: { $in: [this.client.userID] },
-      name: { $autocomplete: searchQuery },
-      ...this.filters
-    };
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: {
+        ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
+        ...this.filters
+      },
+      context: { searchQuery }
+    });
     const sort = this.sort ?? {};
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
     const items = await this.client.queryChannels(filters, sort, options);
@@ -19571,23 +19835,48 @@ var ChannelSearchSource = class extends BaseSearchSource {
 
 // src/search/MessageSearchSource.ts
 var MessageSearchSource = class extends BaseSearchSource {
-  constructor(client, options) {
+  constructor(client, options, filterBuilderOptions) {
     super(options);
     this.type = "messages";
     this.client = client;
+    this.messageSearchChannelFilterBuilder = new FilterBuilder(filterBuilderOptions?.messageSearchChannel);
+    this.messageSearchFilterBuilder = new FilterBuilder({
+      ...filterBuilderOptions?.messageSearch,
+      initialFilterConfig: {
+        text: {
+          enabled: true,
+          generate: ({ searchQuery }) => searchQuery ? { text: searchQuery } : null
+        },
+        ...filterBuilderOptions?.messageSearch?.initialFilterConfig
+      }
+    });
+    this.channelQueryFilterBuilder = new FilterBuilder({
+      ...filterBuilderOptions?.channelQuery,
+      initialFilterConfig: {
+        cid: {
+          enabled: true,
+          generate: ({ cids }) => cids ? { cid: { $in: cids } } : null
+        },
+        ...filterBuilderOptions?.channelQuery?.initialFilterConfig
+      }
+    });
   }
   async query(searchQuery) {
-    if (!this.client.userID) return { items: [] };
-    const channelFilters = {
-      members: { $in: [this.client.userID] },
-      ...this.messageSearchChannelFilters
-    };
-    const 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
-    };
+    if (!this.client.userID || !searchQuery || this.next === null) return { items: [] };
+    const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
+      baseFilters: {
+        ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
+        ...this.messageSearchChannelFilters
+      },
+      context: { searchQuery }
+    });
+    const messageFilters = this.messageSearchFilterBuilder.buildFilters({
+      baseFilters: {
+        type: "regular",
+        ...this.messageSearchFilters
+      },
+      context: { searchQuery }
+    });
     const sort = {
       created_at: -1,
       ...this.messageSearchSort
@@ -19608,15 +19897,14 @@ var MessageSearchSource = class extends BaseSearchSource {
         if (message.cid && !this.client.activeChannels[message.cid]) acc.add(message.cid);
         return acc;
       }, /* @__PURE__ */ new Set())
-      // keep the cids unique
     );
-    const allChannelsLoadedLocally = cids.length === 0;
-    if (!allChannelsLoadedLocally) {
+    if (cids.length > 0) {
+      const channelQueryFilters = this.channelQueryFilterBuilder.buildFilters({
+        baseFilters: this.channelQueryFilters,
+        context: { cids }
+      });
       await this.client.queryChannels(
-        {
-          cid: { $in: cids },
-          ...this.channelQueryFilters
-        },
+        channelQueryFilters,
         {
           last_message_at: -1,
           ...this.channelQuerySort
@@ -23014,6 +23302,15 @@ var Channel = class {
           }
         }
         break;
+      case "user.messages.deleted":
+        if (event.user) {
+          this.state.deleteUserMessages(
+            event.user,
+            !!event.hard_delete,
+            new Date(event.created_at ?? Date.now())
+          );
+        }
+        break;
       case "message.new":
         if (event.message) {
           const ownMessage = event.user?.id === this.getClient().user?.id;
@@ -25920,162 +26217,6 @@ _Reminder.toStateValue = (data) => ({
 });
 var Reminder = _Reminder;
 
-// src/pagination/BasePaginator.ts
-var DEFAULT_PAGINATION_OPTIONS = {
-  debounceMs: 300,
-  pageSize: 10
-};
-var BasePaginator = class {
-  constructor(options) {
-    this._isCursorPagination = false;
-    this.setDebounceOptions = ({ debounceMs }) => {
-      this._executeQueryDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-    };
-    this.canExecuteQuery = (direction) => !this.isLoading && direction === "next" && this.hasNext || direction === "prev" && this.hasPrev;
-    this.next = () => this.executeQuery({ direction: "next" });
-    this.prev = () => this.executeQuery({ direction: "prev" });
-    this.nextDebounced = () => {
-      this._executeQueryDebounced({ direction: "next" });
-    };
-    this.prevDebounced = () => {
-      this._executeQueryDebounced({ direction: "prev" });
-    };
-    const { debounceMs, pageSize } = { ...DEFAULT_PAGINATION_OPTIONS, ...options };
-    this.pageSize = pageSize;
-    this.state = new StateStore(this.initialState);
-    this.setDebounceOptions({ debounceMs });
-  }
-  get lastQueryError() {
-    return this.state.getLatestValue().lastQueryError;
-  }
-  get hasNext() {
-    return this.state.getLatestValue().hasNext;
-  }
-  get hasPrev() {
-    return this.state.getLatestValue().hasPrev;
-  }
-  get hasResults() {
-    return Array.isArray(this.state.getLatestValue().items);
-  }
-  get isLoading() {
-    return this.state.getLatestValue().isLoading;
-  }
-  get initialState() {
-    return {
-      hasNext: true,
-      hasPrev: true,
-      //todo: check if optimistic value does not cause problems in UI
-      isLoading: false,
-      items: void 0,
-      lastQueryError: void 0,
-      cursor: void 0,
-      offset: 0
-    };
-  }
-  get items() {
-    return this.state.getLatestValue().items;
-  }
-  get cursor() {
-    return this.state.getLatestValue().cursor;
-  }
-  get offset() {
-    return this.state.getLatestValue().offset;
-  }
-  getStateBeforeFirstQuery() {
-    return {
-      ...this.initialState,
-      isLoading: true
-    };
-  }
-  getStateAfterQuery(stateUpdate, isFirstPage) {
-    const current = this.state.getLatestValue();
-    return {
-      ...current,
-      lastQueryError: void 0,
-      // reset lastQueryError that can be overridden by the stateUpdate
-      ...stateUpdate,
-      isLoading: false,
-      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
-    };
-  }
-  async executeQuery({ direction }) {
-    if (!this.canExecuteQuery(direction)) return;
-    const isFirstPage = typeof this.items === "undefined";
-    if (isFirstPage) {
-      this.state.next(this.getStateBeforeFirstQuery());
-    } else {
-      this.state.partialNext({ isLoading: true });
-    }
-    const stateUpdate = {};
-    try {
-      const results = await this.query({ direction });
-      if (!results) return;
-      const { items, next, prev } = results;
-      if (isFirstPage && (next || prev)) {
-        this._isCursorPagination = true;
-      }
-      if (this._isCursorPagination) {
-        stateUpdate.cursor = { next: next || null, prev: prev || null };
-        stateUpdate.hasNext = !!next;
-        stateUpdate.hasPrev = !!prev;
-      } 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;
-    } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, isFirstPage));
-    }
-  }
-  cancelScheduledQuery() {
-    this._executeQueryDebounced.cancel();
-  }
-  resetState() {
-    this.state.next(this.initialState);
-  }
-};
-
-// src/pagination/ReminderPaginator.ts
-var ReminderPaginator = class extends BasePaginator {
-  constructor(client, options) {
-    super(options);
-    this.query = async ({
-      direction
-    }) => {
-      const cursor = this.cursor?.[direction];
-      const {
-        reminders: items,
-        next,
-        prev
-      } = await this.client.queryReminders({
-        filter: this.filters,
-        sort: this.sort,
-        limit: this.pageSize,
-        [direction]: cursor
-      });
-      return { items, next, prev };
-    };
-    this.filterQueryResults = (items) => items;
-    this.client = client;
-  }
-  get filters() {
-    return this._filters;
-  }
-  get sort() {
-    return this._sort;
-  }
-  set filters(filters) {
-    this._filters = filters;
-    this.resetState();
-  }
-  set sort(sort) {
-    this._sort = sort;
-    this.resetState();
-  }
-};
-
 // src/reminders/ReminderManager.ts
 var oneMinute2 = 60 * 1e3;
 var oneHour2 = 60 * oneMinute2;
@@ -26638,13 +26779,13 @@ var StreamChat = class _StreamChat {
      * @param {UserResponse} user
      * @param {boolean} hardDelete
      */
-    this._deleteUserMessageReference = (user, hardDelete = false) => {
+    this._deleteUserMessageReference = (user, hardDelete = false, deletedAt) => {
       const refMap = this.state.userChannelReferences[user.id] || {};
       for (const channelID in refMap) {
         const channel = this.activeChannels[channelID];
         if (channel) {
           const state = channel.state;
-          state?.deleteUserMessages(user, hardDelete);
+          state?.deleteUserMessages(user, hardDelete, deletedAt);
         }
       }
     };
@@ -26690,7 +26831,11 @@ var StreamChat = class _StreamChat {
         this._updateUserMessageReferences(event.user);
       }
       if (event.type === "user.deleted" && 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
+        );
       }
     };
     this._callClientListeners = (event) => {
@@ -27260,6 +27405,13 @@ var StreamChat = class _StreamChat {
     if (event.type === "user.presence.changed" || event.type === "user.updated" || event.type === "user.deleted") {
       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);
@@ -28520,7 +28672,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.15.0";
+    const version = "9.17.0";
     const clientBundle = "node-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -29718,6 +29870,7 @@ var 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,
@@ -30882,6 +31035,7 @@ var FixedSizeQueueCache = class {
   DevToken,
   EVENT_MAP,
   ErrorFromResponse,
+  FilterBuilder,
   FixedSizeQueueCache,
   InsightMetrics,
   JWTServerToken,