stream-chat 9.50.3 → 10.0.0-rc.2

package/src/utils.ts

@@ -1,23 +1,12 @@
 import FormData from 'form-data';
 import type {
-  AscDesc,
-  ChannelFilters,
-  ChannelQueryOptions,
-  ChannelSort,
-  ChannelSortBase,
   LocalMessage,
-  LocalMessageBase,
-  Logger,
-  Message,
-  MessagePaginationOptions,
+  MessageRequest,
   MessageResponse,
-  MessageResponseBase,
-  MessageSet,
   OwnUserBase,
   OwnUserResponse,
-  PromoteChannelParams,
-  QueryChannelAPIResponse,
   ReactionGroupResponse,
+  ReactionResponse,
   UpdatedMessage,
   UserResponse,
 } from './types';
@@ -25,18 +14,22 @@ import type { StreamChat } from './client';
 import type { Channel } from './channel';
 import type { AxiosRequestConfig } from 'axios';
 import { LOCAL_MESSAGE_FIELDS, RESERVED_UPDATED_MESSAGE_FIELDS } from './constants';
+import { chatLoggerSystem } from './logger';
+
+const logger = chatLoggerSystem.getLogger('utils');
 
 /**
- * logChatPromiseExecution - utility function for logging the execution of a promise..
- *  use this when you want to run the promise and handle errors by logging a warning
- *
- * @param {Promise<T>} promise The promise you want to run and log
- * @param {string} name    A descriptive name of what the promise does for log output
+ * Logs the execution of a promise. Use this when you want to run the promise and handle errors by
+ * logging a warning.
  *
+ * @param promise - The promise you want to run and log.
+ * @param name - A descriptive name of what the promise does for log output.
  */
 export function logChatPromiseExecution<T>(promise: Promise<T>, name: string) {
   promise.then().catch((error) => {
-    console.warn(`failed to do ${name}, ran into error: `, error);
+    logger
+      .withExtraTags('logChatPromiseExecution')
+      .error(`Failed to execute "${name}".`, { error });
   });
 }
 
@@ -153,29 +146,11 @@ export function addFileToFormData(
 
   return data;
 }
-export function normalizeQuerySort<T extends Record<string, AscDesc | undefined>>(
-  sort: T | T[],
-) {
-  const sortFields: Array<{ direction: AscDesc; field: keyof T }> = [];
-  const sortArr = Array.isArray(sort) ? sort : [sort];
-  for (const item of sortArr) {
-    const entries = Object.entries(item) as [keyof T, AscDesc][];
-    if (entries.length > 1) {
-      console.warn(
-        "client._buildSort() - multiple fields in a single sort object detected. Object's field order is not guaranteed",
-      );
-    }
-    for (const [field, direction] of entries) {
-      sortFields.push({ field, direction });
-    }
-  }
-  return sortFields;
-}
 
 /**
  * retryInterval - A retry interval which increases acc to number of failures
  *
- * @return {number} Duration to wait in milliseconds
+ * @returns Duration to wait in milliseconds
  */
 export function retryInterval(numberOfFailures: number) {
   // try to reconnect in 0.25-25 seconds (random to spread out the load from failures)
@@ -270,9 +245,9 @@ export function isOnline() {
         : undefined;
 
   if (!nav) {
-    console.warn(
-      'isOnline failed to access window.navigator and assume browser is online',
-    );
+    logger
+      .withExtraTags('isOnline')
+      .warn('Could not access window.navigator; assuming the browser is online.');
     return true;
   }
 
@@ -319,102 +294,204 @@ 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 LocalMessage object.
+ * Takes the message object, adds SDK-specific fields (status, error),
+ * and returns a new LocalMessage object.
  *
- * @param {LocalMessage} message `LocalMessage` object
+ * @param message - message object
  */
-export function formatMessage(
-  message: MessageResponse | MessageResponseBase | LocalMessage,
-): LocalMessage {
+export function formatMessage(message: MessageResponse | LocalMessage): LocalMessage {
   const toLocalMessageBase = (
-    msg: MessageResponse | MessageResponseBase | LocalMessage | null | undefined,
-  ): LocalMessageBase | null => {
+    msg: MessageResponse | LocalMessage | null | undefined,
+  ): LocalMessage | null => {
     if (!msg) return null;
     return {
       ...msg,
       created_at: msg.created_at ? new Date(msg.created_at) : new Date(),
-      deleted_at: msg.deleted_at ? new Date(msg.deleted_at) : null,
-      pinned_at: msg.pinned_at ? new Date(msg.pinned_at) : null,
+      deleted_at: msg.deleted_at ? new Date(msg.deleted_at) : undefined,
+      pinned_at: msg.pinned_at ? new Date(msg.pinned_at) : undefined,
       reaction_groups: maybeGetReactionGroupsFallback(
         msg.reaction_groups,
         msg.reaction_counts,
         msg.reaction_scores,
       ),
-      status: msg.status || 'received',
+      status: (msg as LocalMessage).status || 'received',
       updated_at: msg.updated_at ? new Date(msg.updated_at) : new Date(),
     };
   };
 
   return {
     ...toLocalMessageBase(message),
-    error: (message as LocalMessage).error ?? null,
-    quoted_message: toLocalMessageBase((message as MessageResponse).quoted_message),
+    error: (message as LocalMessage).error ?? undefined,
+    quoted_message:
+      toLocalMessageBase((message as MessageResponse).quoted_message) ?? undefined,
   } as LocalMessage;
 }
 
 /**
- * @private
+ * Computes the current user's `own_reactions` after applying a single reaction change, off a
+ * `current` base. A WS reaction/edit event carries `own_reactions: []` (or stale), so consumers
+ * must recompute from the copy they already hold rather than trusting the event — this is the
+ * shared core used by both the message paginator (`reflectReaction`) and the thread's parent
+ * message (which is not held in any paginator, so it needs the same logic directly).
  *
- * Takes a LocalMessage, parses the dates back to strings,
- * and converts the message back to a MessageResponse.
+ * - `removed`: drop the current user's reaction of this type.
+ * - `enforceUnique`: replace any existing own reaction with the incoming one (used by
+ *   `reaction.updated`, where a user's reaction supersedes their previous one).
+ * - otherwise: add the reaction, de-duped by type.
  *
- * @param {MessageResponse} message `MessageResponse` object
+ * A reaction by another user never changes the current user's `own_reactions`.
  */
-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,
-    };
+export function computeOwnReactions({
+  current,
+  enforceUnique = false,
+  reaction,
+  removed = false,
+  userId,
+}: {
+  current: ReactionResponse[];
+  reaction: ReactionResponse;
+  enforceUnique?: boolean;
+  removed?: boolean;
+  userId?: string;
+}): ReactionResponse[] {
+  const withoutType = current.filter(
+    (r) => r.user_id !== reaction.user_id || r.type !== reaction.type,
+  );
+  if (removed) return withoutType;
+  if (userId !== reaction.user_id) return withoutType;
+  return enforceUnique ? [reaction] : [...withoutType, reaction];
+}
+
+/**
+ * Returns a copy of `message` with `reaction` folded into its `reaction_groups` /
+ * `latest_reactions`. Does not touch `own_reactions` — the reaction entry points
+ * ({@link MessageIntervalPaginator.reflectReaction} / `Thread.applyParentReactionLocally`) own that
+ * via {@link computeOwnReactions}. Shared so both the paginator and the (paginator-less) thread
+ * parent compute counts identically.
+ */
+export function messageWithReactionAdded(
+  message: LocalMessage,
+  reaction: ReactionResponse,
+  enforceUnique: boolean,
+): LocalMessage {
+  const score = reaction.score ?? 1;
+  const reactionGroups: Record<string, ReactionGroupResponse> = {
+    ...(message.reaction_groups ?? {}),
   };
 
+  // When enforcing uniqueness, first back the current user's existing reactions out of the groups
+  if (enforceUnique) {
+    for (const ownReaction of message.own_reactions ?? []) {
+      const group = reactionGroups[ownReaction.type];
+      if (!group) continue;
+      const next = {
+        ...group,
+        count: group.count - 1,
+        sum_scores: group.sum_scores - (ownReaction.score ?? 1),
+      };
+      if (next.count < 1) delete reactionGroups[ownReaction.type];
+      else reactionGroups[ownReaction.type] = next;
+    }
+  }
+
+  const existingGroup = reactionGroups[reaction.type];
+  reactionGroups[reaction.type] = existingGroup
+    ? {
+        ...existingGroup,
+        count: existingGroup.count + 1,
+        last_reaction_at: reaction.created_at,
+        sum_scores: existingGroup.sum_scores + score,
+      }
+    : {
+        count: 1,
+        first_reaction_at: reaction.created_at,
+        last_reaction_at: reaction.created_at,
+        latest_reactions_by: [],
+        sum_scores: score,
+      };
+
+  const latestReactions = enforceUnique
+    ? [
+        ...(message.latest_reactions ?? []).filter((r) => r.user_id !== reaction.user_id),
+        reaction,
+      ]
+    : [...(message.latest_reactions ?? []), reaction];
+
   return {
-    ...toMessageResponseBase(message),
-    quoted_message: toMessageResponseBase((message as LocalMessage).quoted_message),
-  } as MessageResponse;
+    ...message,
+    latest_reactions: latestReactions,
+    reaction_groups: reactionGroups,
+  };
 }
 
-export const localMessageToNewMessagePayload = (localMessage: LocalMessage): Message => {
-  /* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Returns a copy of `message` with the current user's reaction of `reaction.type` backed out of its
+ * `reaction_groups` / `latest_reactions`. Does not touch `own_reactions`.
+ */
+export function messageWithReactionRemoved(
+  message: LocalMessage,
+  reaction: ReactionResponse,
+): LocalMessage {
+  const reactionGroups: Record<string, ReactionGroupResponse> = {
+    ...(message.reaction_groups ?? {}),
+  };
+  const reactionToRemove = message.own_reactions?.find((r) => r.type === reaction.type);
+
+  if (reactionToRemove && reactionGroups[reactionToRemove.type]) {
+    const group = reactionGroups[reactionToRemove.type];
+    const next = {
+      ...group,
+      count: group.count - 1,
+      sum_scores: group.sum_scores - (reactionToRemove.score ?? 1),
+    };
+    if (next.count < 1) delete reactionGroups[reactionToRemove.type];
+    else reactionGroups[reactionToRemove.type] = next;
+  }
+
+  return {
+    ...message,
+    latest_reactions: message.latest_reactions?.filter(
+      (r) => !(r.user_id === reaction.user_id && r.type === reaction.type),
+    ),
+    reaction_groups: reactionGroups,
+  };
+}
+
+export const localMessageToNewMessagePayload = (
+  localMessage: LocalMessage,
+): MessageRequest => {
   const {
     // Remove all timestamp fields and client-specific fields.
     // Field pinned_at can therefore be earlier than created_at as new message payload can hold it.
-    created_at,
-    updated_at,
-    deleted_at,
+    created_at: _created_at,
+    updated_at: _updated_at,
+    deleted_at: _deleted_at,
     // Client-specific fields
-    error,
-    status,
+    error: _error,
+    status: _status,
     // Reaction related fields
-    latest_reactions,
-    own_reactions,
-    reaction_counts,
-    reaction_scores,
-    reply_count,
-    // Message text related fields that shouldn't be in update
-    command,
-    html,
-    i18n,
-    mentioned_groups,
-    quoted_message,
+    latest_reactions: _latest_reactions,
+    own_reactions: _own_reactions,
+    reaction_counts: _reaction_counts,
+    reaction_scores: _reaction_scores,
+    reply_count: _reply_count,
+    // MessageRequest text related fields that shouldn't be in update
+    command: _command,
+    html: _html,
+    i18n: _i18n,
+    mentioned_groups: _mentioned_groups,
+    quoted_message: _quoted_message,
     mentioned_users,
-    // Message content related fields
+    // MessageRequest content related fields
     ...messageFields
   } = localMessage;
 
+  // `messageFields` still carries LocalMessage-only fields (cid, deleted_reply_count, mentioned_*,
+  // pinned, shadowed, …) that the stricter OpenAPI `MessageRequest` omits; the server ignores them.
   return {
     ...messageFields,
-    pinned_at: messageFields.pinned_at?.toISOString(),
     mentioned_users: mentioned_users?.map((user) => user.id),
-  };
+  } as MessageRequest;
 };
 
 export const toUpdatedMessagePayload = (
@@ -445,7 +522,7 @@ export const toDeletedMessage = ({
   deletedAt,
   hardDelete = false,
 }: {
-  message: LocalMessage | LocalMessageBase;
+  message: LocalMessage;
   deletedAt: LocalMessage['deleted_at'];
   hardDelete: boolean;
 }) => {
@@ -453,7 +530,7 @@ export const toDeletedMessage = ({
     /**
      * 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
+     * FIXME: we are returning an object that does not match LocalMessage
      */
     return {
       attachments: [],
@@ -482,39 +559,6 @@ export const toDeletedMessage = ({
   }
 };
 
-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 (messages[i].quoted_message && 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,
@@ -604,77 +648,11 @@ export const findIndexInSortedArray = <T, L>({
   return left;
 };
 
-export function addToMessageList<T extends LocalMessage>(
-  messages: readonly T[],
-  newMessage: T,
-  timestampChanged = false,
-  sortBy: 'pinned_at' | 'created_at' = 'created_at',
-  addIfDoesNotExist = true,
-) {
-  const addMessageToList = addIfDoesNotExist || timestampChanged;
-  let newMessages = [...messages];
-
-  // if created_at has changed, message should be filtered and re-inserted in correct order
-  // slow op but usually this only happens for a message inserted to state before actual response with correct timestamp
-  if (timestampChanged) {
-    newMessages = newMessages.filter(
-      (message) => !(message.id && newMessage.id === message.id),
-    );
-  }
-
-  // for empty list just concat and return unless it's an update or deletion
-  if (newMessages.length === 0 && addMessageToList) {
-    return newMessages.concat(newMessage);
-  } else if (newMessages.length === 0) {
-    return newMessages;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const messageTime = newMessage[sortBy]!.getTime();
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const messageIsNewest = newMessages.at(-1)![sortBy]!.getTime() < messageTime;
-
-  // if message is newer than last item in the list concat and return unless it's an update or deletion
-  if (messageIsNewest && addMessageToList) {
-    return newMessages.concat(newMessage);
-  } else if (messageIsNewest) {
-    return newMessages;
-  }
-
-  // find the closest index to push the new message
-  const insertionIndex = findIndexInSortedArray({
-    needle: newMessage,
-    sortedArray: newMessages,
-    sortDirection: 'ascending',
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    selectValueToCompare: (m) => m[sortBy]!.getTime(),
-    selectKey: (m) => m.id,
-  });
-
-  // message already exists and not filtered with timestampChanged, update and return
-  if (
-    !timestampChanged &&
-    newMessage.id &&
-    newMessages[insertionIndex] &&
-    newMessage.id === newMessages[insertionIndex].id
-  ) {
-    newMessages[insertionIndex] = newMessage;
-    return newMessages;
-  }
-
-  // do not add updated or deleted messages to the list if they already exist or come with a timestamp change
-  if (addMessageToList) {
-    newMessages.splice(insertionIndex, 0, newMessage);
-  }
-
-  return newMessages;
-}
-
 function maybeGetReactionGroupsFallback(
   groups: { [key: string]: ReactionGroupResponse } | null | undefined,
   counts: { [key: string]: number } | null | undefined,
   scores: { [key: string]: number } | null | undefined,
-): { [key: string]: ReactionGroupResponse } | null {
+): { [key: string]: ReactionGroupResponse } | undefined {
   if (groups) {
     return groups;
   }
@@ -683,19 +661,20 @@ function maybeGetReactionGroupsFallback(
     const fallback: { [key: string]: ReactionGroupResponse } = {};
 
     for (const type of Object.keys(counts)) {
+      // Best-effort fallback derived from counts/scores; the richer OpenAPI `ReactionGroupResponse`
+      // fields (first/last_reaction_at, latest_reactions_by) are not available here.
       fallback[type] = {
         count: counts[type],
         sum_scores: scores[type],
-      };
+      } as ReactionGroupResponse;
     }
 
     return fallback;
   }
 
-  return null;
+  return undefined;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface DebouncedFunc<T extends (...args: any[]) => any> {
   /**
    * Call the original function, but applying the debounce rules.
@@ -724,7 +703,7 @@ export interface DebouncedFunc<T extends (...args: any[]) => any> {
 }
 
 // works exactly the same as lodash.debounce
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
 export const debounce = <T extends (...args: any[]) => any>(
   fn: T,
   timeout = 0,
@@ -771,39 +750,14 @@ export const debounce = <T extends (...args: any[]) => any>(
   return debouncedFn;
 };
 
-// works exactly the same as lodash.throttle
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const throttle = <T extends (...args: any[]) => any>(
-  fn: T,
-  timeout = 200,
-  { leading = true, trailing = false }: { leading?: boolean; trailing?: boolean } = {},
-) => {
-  let runningTimeout: null | NodeJS.Timeout = null;
-  let storedArgs: Parameters<T> | null = null;
-
-  return (...args: Parameters<T>) => {
-    if (runningTimeout) {
-      if (trailing) storedArgs = args;
-      return;
-    }
-
-    if (leading) fn(...args);
-
-    const timeoutHandler = () => {
-      if (storedArgs) {
-        fn(...storedArgs);
-        storedArgs = null;
-        runningTimeout = setTimeout(timeoutHandler, timeout);
-
-        return;
-      }
-
-      runningTimeout = null;
-    };
-
-    runningTimeout = setTimeout(timeoutHandler, timeout);
-  };
-};
+// The single throttle implementation lives in ./utils/throttling/throttle; re-exported here so
+// `import { throttle } from './utils'` keeps working (lodash.throttle-style leading/trailing).
+export { throttle } from './utils/throttling/throttle';
+export type {
+  Throttled,
+  ThrottleOptions,
+  ThrottledCallback,
+} from './utils/throttling/throttle';
 
 const get = <T>(obj: T, path: string): unknown =>
   path.split('.').reduce<unknown>((acc, key) => {
@@ -830,342 +784,13 @@ export const uniqBy = <T>(
   });
 };
 
-type MessagePaginationUpdatedParams = {
-  parentSet: MessageSet;
-  requestedPageSize: number;
-  returnedPage: MessageResponse[];
-  filteredReturnedPage: MessageResponse[];
-  logger?: Logger;
-  messagePaginationOptions?: MessagePaginationOptions;
-};
-
-export function binarySearchByDateEqualOrNearestGreater(
-  array: {
-    created_at?: string;
-  }[],
-  targetDate: Date,
-): number {
-  let left = 0;
-  let right = array.length - 1;
-
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    const midCreatedAt = array[mid].created_at;
-    if (!midCreatedAt) {
-      left += 1;
-      continue;
-    }
-    const midDate = new Date(midCreatedAt);
-
-    if (midDate.getTime() === targetDate.getTime()) {
-      return mid;
-    } else if (midDate.getTime() < targetDate.getTime()) {
-      left = mid + 1;
-    } else {
-      right = mid - 1;
-    }
-  }
-
-  return left;
-}
-
-const messagePaginationCreatedAtAround = ({
-  parentSet,
-  requestedPageSize,
-  returnedPage,
-  filteredReturnedPage,
-  messagePaginationOptions,
-}: MessagePaginationUpdatedParams) => {
-  const newPagination = { ...parentSet.pagination };
-  if (!messagePaginationOptions?.created_at_around) return newPagination;
-  let hasPrev;
-  let hasNext;
-  let updateHasPrev;
-  let updateHasNext;
-  const createdAtAroundDate = new Date(messagePaginationOptions.created_at_around);
-  const [firstPageMsg, lastPageMsg] = [returnedPage[0], returnedPage.slice(-1)[0]];
-
-  // expect ASC order (from oldest to newest)
-  const wholePageHasNewerMessages =
-    !!firstPageMsg?.created_at && new Date(firstPageMsg.created_at) > createdAtAroundDate;
-  const wholePageHasOlderMessages =
-    !!lastPageMsg?.created_at && new Date(lastPageMsg.created_at) < createdAtAroundDate;
-
-  const requestedPageSizeNotMet =
-    requestedPageSize > parentSet.messages.length &&
-    requestedPageSize > returnedPage.length;
-  const noMoreMessages =
-    (requestedPageSize > parentSet.messages.length ||
-      parentSet.messages.length >= returnedPage.length) &&
-    requestedPageSize > returnedPage.length;
-
-  if (wholePageHasNewerMessages) {
-    hasPrev = false;
-    updateHasPrev = true;
-    if (requestedPageSizeNotMet) {
-      hasNext = false;
-      updateHasNext = true;
-    }
-  } else if (wholePageHasOlderMessages) {
-    hasNext = false;
-    updateHasNext = true;
-    if (requestedPageSizeNotMet) {
-      hasPrev = false;
-      updateHasPrev = true;
-    }
-  } else if (noMoreMessages) {
-    hasNext = hasPrev = false;
-    updateHasPrev = updateHasNext = true;
-  } else {
-    const [firstFilteredPageMsg, lastFilteredPageMsg] = [
-      filteredReturnedPage[0],
-      filteredReturnedPage.slice(-1)[0],
-    ];
-    const [firstPageMsgIsFirstInSet, lastPageMsgIsLastInSet] = [
-      firstFilteredPageMsg?.id && firstFilteredPageMsg.id === parentSet.messages[0]?.id,
-      lastFilteredPageMsg?.id &&
-        lastFilteredPageMsg.id === parentSet.messages.slice(-1)[0]?.id,
-    ];
-    updateHasPrev = firstPageMsgIsFirstInSet;
-    updateHasNext = lastPageMsgIsLastInSet;
-    const midPointByCount = Math.floor(returnedPage.length / 2);
-    const midPointByCreationDate = binarySearchByDateEqualOrNearestGreater(
-      returnedPage,
-      createdAtAroundDate,
-    );
-
-    if (midPointByCreationDate !== -1) {
-      hasPrev = midPointByCount <= midPointByCreationDate;
-      hasNext = midPointByCount >= midPointByCreationDate;
-    }
-  }
-
-  if (updateHasPrev && typeof hasPrev !== 'undefined') newPagination.hasPrev = hasPrev;
-  if (updateHasNext && typeof hasNext !== 'undefined') newPagination.hasNext = hasNext;
-
-  return newPagination;
-};
-
-const messagePaginationIdAround = ({
-  parentSet,
-  requestedPageSize,
-  returnedPage,
-  filteredReturnedPage,
-  messagePaginationOptions,
-}: MessagePaginationUpdatedParams) => {
-  const newPagination = { ...parentSet.pagination };
-  const { id_around } = messagePaginationOptions || {};
-  if (!id_around) return newPagination;
-  let hasPrev;
-  let hasNext;
-
-  const [firstFilteredPageMsg, lastFilteredPageMsg] = [
-    filteredReturnedPage[0],
-    filteredReturnedPage.slice(-1)[0],
-  ];
-  const [firstPageMsgIsFirstInSet, lastPageMsgIsLastInSet] = [
-    firstFilteredPageMsg?.id === parentSet.messages[0]?.id,
-    lastFilteredPageMsg?.id === parentSet.messages.slice(-1)[0]?.id,
-  ];
-  let updateHasPrev = firstPageMsgIsFirstInSet;
-  let updateHasNext = lastPageMsgIsLastInSet;
-
-  const midPoint = Math.floor(returnedPage.length / 2);
-  const noMoreMessages =
-    (requestedPageSize > parentSet.messages.length ||
-      parentSet.messages.length >= returnedPage.length) &&
-    requestedPageSize > returnedPage.length;
-
-  if (noMoreMessages) {
-    hasNext = hasPrev = false;
-    updateHasPrev = updateHasNext = true;
-  } else if (!returnedPage[midPoint]) {
-    return newPagination;
-  } else if (returnedPage[midPoint].id === id_around) {
-    hasPrev = hasNext = true;
-  } else {
-    let targetMsg;
-    const halves = [returnedPage.slice(0, midPoint), returnedPage.slice(midPoint)];
-    hasPrev = hasNext = true;
-    for (let i = 0; i < halves.length; i++) {
-      targetMsg = halves[i].find((message) => message.id === id_around);
-      if (targetMsg && i === 0) {
-        hasPrev = false;
-      }
-      if (targetMsg && i === 1) {
-        hasNext = false;
-      }
-    }
-  }
-
-  if (updateHasPrev && typeof hasPrev !== 'undefined') newPagination.hasPrev = hasPrev;
-  if (updateHasNext && typeof hasNext !== 'undefined') newPagination.hasNext = hasNext;
-
-  return newPagination;
-};
-
-const messagePaginationLinear = ({
-  parentSet,
-  requestedPageSize,
-  returnedPage,
-  filteredReturnedPage,
-  messagePaginationOptions,
-}: MessagePaginationUpdatedParams) => {
-  const newPagination = { ...parentSet.pagination };
-
-  let hasPrev;
-  let hasNext;
-
-  const [firstFilteredPageMsg, lastFilteredPageMsg] = [
-    filteredReturnedPage[0],
-    filteredReturnedPage.slice(-1)[0],
-  ];
-  const [firstPageMsgIsFirstInSet, lastPageMsgIsLastInSet] = [
-    firstFilteredPageMsg?.id && firstFilteredPageMsg.id === parentSet.messages[0]?.id,
-    lastFilteredPageMsg?.id &&
-      lastFilteredPageMsg.id === parentSet.messages.slice(-1)[0]?.id,
-  ];
-
-  const queriedNextMessages =
-    messagePaginationOptions &&
-    (messagePaginationOptions.created_at_after_or_equal ||
-      messagePaginationOptions.created_at_after ||
-      messagePaginationOptions.id_gt ||
-      messagePaginationOptions.id_gte);
-
-  const queriedPrevMessages =
-    typeof messagePaginationOptions === 'undefined'
-      ? true
-      : messagePaginationOptions.created_at_before_or_equal ||
-        messagePaginationOptions.created_at_before ||
-        messagePaginationOptions.id_lt ||
-        messagePaginationOptions.id_lte ||
-        messagePaginationOptions.offset;
-
-  const containsUnrecognizedOptionsOnly =
-    !queriedNextMessages &&
-    !queriedPrevMessages &&
-    !messagePaginationOptions?.id_around &&
-    !messagePaginationOptions?.created_at_around;
-
-  const hasMore = returnedPage.length >= requestedPageSize;
-
-  if (typeof queriedPrevMessages !== 'undefined' || containsUnrecognizedOptionsOnly) {
-    hasPrev = hasMore;
-  }
-  if (typeof queriedNextMessages !== 'undefined') {
-    hasNext = hasMore;
-  }
-  const returnedPageIsEmpty = returnedPage.length === 0;
-
-  if ((firstPageMsgIsFirstInSet || returnedPageIsEmpty) && typeof hasPrev !== 'undefined')
-    newPagination.hasPrev = hasPrev;
-  if ((lastPageMsgIsLastInSet || returnedPageIsEmpty) && typeof hasNext !== 'undefined')
-    newPagination.hasNext = hasNext;
-
-  return newPagination;
-};
-
-export const messageSetPagination = (params: MessagePaginationUpdatedParams) => {
-  if (
-    params.parentSet.messages.length +
-      (params.returnedPage.length - params.filteredReturnedPage.length) <
-    params.returnedPage.length
-  ) {
-    params.logger?.(
-      'error',
-      'Corrupted message set state: parent set size < returned page size',
-    );
-    return params.parentSet.pagination;
-  }
-
-  if (params.messagePaginationOptions?.created_at_around) {
-    return messagePaginationCreatedAtAround(params);
-  } else if (params.messagePaginationOptions?.id_around) {
-    return messagePaginationIdAround(params);
-  } else {
-    return messagePaginationLinear(params);
-  }
-};
-
-/**
- * A utility object used to prevent duplicate invocation of channel.watch() to be triggered when
- * 'notification.message_new' and 'notification.added_to_channel' events arrive at the same time.
- */
-const WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL: Record<
-  string,
-  Promise<QueryChannelAPIResponse> | undefined
-> = {};
-
-type GetChannelParams = {
-  client: StreamChat;
-  channel?: Channel;
-  id?: string;
-  members?: string[];
-  options?: ChannelQueryOptions;
-  type?: string;
-};
-/**
- * Calls channel.watch() if it was not already recently called. Waits for watch promise to resolve even if it was invoked previously.
- * If the channel is not passed as a property, it will get it either by its channel.cid or by its members list and do the same.
- * @param client
- * @param members
- * @param options
- * @param type
- * @param id
- * @param channel
- */
-export const getAndWatchChannel = async ({
-  channel,
-  client,
-  id,
-  members,
-  options,
-  type,
-}: GetChannelParams) => {
-  if (!channel && !type) {
-    throw new Error('Channel or channel type have to be provided to query a channel.');
-  }
-
-  // unfortunately typescript is not able to infer that if (!channel && !type) === false, then channel or type has to be truthy
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const channelToWatch = channel || client.channel(type!, id, { members });
-
-  // need to keep as with call to channel.watch the id can be changed from undefined to an actual ID generated server-side
-  const originalCid = channelToWatch.id
-    ? channelToWatch.cid
-    : members && members.length
-      ? generateChannelTempCid(channelToWatch.type, members)
-      : undefined;
-
-  if (!originalCid) {
-    throw new Error(
-      'Channel ID or channel members array have to be provided to query a channel.',
-    );
-  }
-
-  const queryPromise = WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid];
-
-  if (queryPromise) {
-    await queryPromise;
-  } else {
-    try {
-      WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid] = channelToWatch.watch(options);
-      await WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid];
-    } finally {
-      delete WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid];
-    }
-  }
-
-  return channelToWatch;
-};
-
 /**
  * Generates a temporary channel.cid for channels created without ID, as they need to be referenced
  * by an identifier until the back-end generates the final ID. The cid is generated by its member IDs
  * which are sorted and can be recreated the same every time given the same arguments.
- * @param channelType
- * @param members
+ *
+ * @param channelType - The channel type.
+ * @param members - The member ids used to build the temporary cid.
  */
 export const generateChannelTempCid = (channelType: string, members: string[]) => {
   if (!members) return;
@@ -1174,186 +799,6 @@ export const generateChannelTempCid = (channelType: string, members: string[]) =
   return `${channelType}:!members-${membersStr}`;
 };
 
-/**
- * Checks if a channel is pinned or not. Will return true only if channel.state.membership.pinned_at exists.
- * @param channel
- */
-export const isChannelPinned = (channel: Channel) => {
-  if (!channel) return false;
-
-  const member = channel.state.membership;
-
-  return !!member?.pinned_at;
-};
-
-/**
- * Checks if a channel is archived or not. Will return true only if channel.state.membership.archived_at exists.
- * @param channel
- */
-export const isChannelArchived = (channel: Channel) => {
-  if (!channel) return false;
-
-  const member = channel.state.membership;
-
-  return !!member?.archived_at;
-};
-
-/**
- * A utility that tells us whether we should consider archived channels or not based
- * on filters. Will return true only if filters.archived exists and is a boolean value.
- * @param filters
- */
-export const shouldConsiderArchivedChannels = (filters: ChannelFilters) => {
-  if (!filters) return false;
-
-  return typeof filters.archived === 'boolean';
-};
-
-/**
- * Extracts the value of the sort parameter at a given index, for a targeted key. Can
- * handle both array and object versions of sort. Will return null if the index/key
- * combination does not exist.
- * @param atIndex - the index at which we'll examine the sort value, if it's an array one
- * @param sort - the sort value - both array and object notations are accepted
- * @param targetKey - the target key which needs to exist for the sort at a certain index
- */
-export const extractSortValue = ({
-  atIndex,
-  sort,
-  targetKey,
-}: {
-  atIndex: number;
-  targetKey: keyof ChannelSortBase;
-  sort?: ChannelSort;
-}) => {
-  if (!sort) return null;
-  let option: null | ChannelSortBase = null;
-
-  if (Array.isArray(sort)) {
-    option = sort[atIndex] ?? null;
-  } else {
-    let index = 0;
-    for (const key in sort) {
-      if (index !== atIndex) {
-        index++;
-        continue;
-      }
-
-      if (key !== targetKey) {
-        return null;
-      }
-
-      option = sort;
-
-      break;
-    }
-  }
-
-  return option?.[targetKey] ?? null;
-};
-
-/**
- * Returns true only if `{ pinned_at: -1 }` or `{ pinned_at: 1 }` option is first within the `sort` array.
- */
-export const shouldConsiderPinnedChannels = (sort: ChannelSort) => {
-  const value = findPinnedAtSortOrder({ sort });
-
-  if (typeof value !== 'number') return false;
-
-  return Math.abs(value) === 1;
-};
-
-/**
- * Checks whether the sort value of type object contains a pinned_at value or if
- * an array sort value type has the first value be an object containing pinned_at.
- * @param sort
- */
-export const findPinnedAtSortOrder = ({ sort }: { sort: ChannelSort }) =>
-  extractSortValue({
-    atIndex: 0,
-    sort,
-    targetKey: 'pinned_at',
-  });
-
-/**
- * Finds the index of the last consecutively pinned channel, starting from the start of the
- * array. Will not consider any pinned channels after the contiguous subsequence at the
- * start of the array.
- * @param channels
- */
-export const findLastPinnedChannelIndex = ({ channels }: { channels: Channel[] }) => {
-  let lastPinnedChannelIndex: number | null = null;
-
-  for (const channel of channels) {
-    if (!isChannelPinned(channel)) break;
-
-    if (typeof lastPinnedChannelIndex === 'number') {
-      lastPinnedChannelIndex++;
-    } else {
-      lastPinnedChannelIndex = 0;
-    }
-  }
-
-  return lastPinnedChannelIndex;
-};
-
-/**
- * A utility used to move a channel towards the beginning of a list of channels (promote it to a higher position). It
- * considers pinned channels in the process if needed and makes sure to only update the list reference if the list
- * should actually change. It will try to move the channel as high as it can within the list.
- * @param channels - the list of channels we want to modify
- * @param channelToMove - the channel we want to promote
- * @param channelToMoveIndexWithinChannels - optionally, the index of the channel we want to move if we know it (will skip a manual check)
- * @param sort - the sort value used to check for pinned channels
- */
-export const promoteChannel = ({
-  channels,
-  channelToMove,
-  channelToMoveIndexWithinChannels,
-  sort,
-}: PromoteChannelParams) => {
-  // get index of channel to move up
-  const targetChannelIndex =
-    channelToMoveIndexWithinChannels ??
-    channels.findIndex((channel) => channel.cid === channelToMove.cid);
-
-  const targetChannelExistsWithinList = targetChannelIndex >= 0;
-  const targetChannelAlreadyAtTheTop = targetChannelIndex === 0;
-
-  // pinned channels should not move within the list based on recent activity, channels which
-  // receive messages and are not pinned should move upwards but only under the last pinned channel
-  // in the list
-  const considerPinnedChannels = shouldConsiderPinnedChannels(sort);
-  const isTargetChannelPinned = isChannelPinned(channelToMove);
-
-  if (targetChannelAlreadyAtTheTop || (considerPinnedChannels && isTargetChannelPinned)) {
-    return channels;
-  }
-
-  const newChannels = [...channels];
-
-  // target channel index is known, remove it from the list
-  if (targetChannelExistsWithinList) {
-    newChannels.splice(targetChannelIndex, 1);
-  }
-
-  // as position of pinned channels has to stay unchanged, we need to
-  // find last pinned channel in the list to move the target channel after
-  let lastPinnedChannelIndex: number | null = null;
-  if (considerPinnedChannels) {
-    lastPinnedChannelIndex = findLastPinnedChannelIndex({ channels: newChannels });
-  }
-
-  // re-insert it at the new place (to specific index if pinned channels are considered)
-  newChannels.splice(
-    typeof lastPinnedChannelIndex === 'number' ? lastPinnedChannelIndex + 1 : 0,
-    0,
-    channelToMove,
-  );
-
-  return newChannels;
-};
-
 export const isDate = (value: unknown): value is Date => !!(value as Date).getTime;
 
 export const isLocalMessage = (message: unknown): message is LocalMessage =>
@@ -1367,9 +812,11 @@ export const runDetached = <T>(
     onErrorCallback?: (error: Error) => void | Promise<void>;
   },
 ) => {
-  const { context, onSuccessCallback = () => undefined, onErrorCallback } = options ?? {};
+  const { context, onSuccessCallback, onErrorCallback } = options ?? {};
   const defaultOnError = (error: Error) => {
-    console.log(`An error has occurred in context ${context}: ${error}`);
+    logger
+      .withExtraTags('runDetached')
+      .error(`An error occurred in context "${context}".`, { error });
   };
   const onError = onErrorCallback ?? defaultOnError;
 
@@ -1383,11 +830,18 @@ export const runDetached = <T>(
 };
 
 export const isBlockedMessage = (message: LocalMessage) =>
-  message.type === 'error' &&
-  (message.moderation_details?.action === 'MESSAGE_RESPONSE_ACTION_REMOVE' ||
-    message.moderation?.action === 'remove');
+  message.type === 'error' && message.moderation?.action === 'remove';
 
 export const isBouncedMessage = (message: LocalMessage) =>
-  message.type === 'error' &&
-  (message?.moderation_details?.action === 'MESSAGE_RESPONSE_ACTION_BOUNCE' ||
-    message?.moderation?.action === 'bounce');
+  message.type === 'error' && message?.moderation?.action === 'bounce';
+
+export const getEnv = (envKey: keyof NodeJS.ProcessEnv) => {
+  if (
+    typeof process !== 'undefined' &&
+    (Object.hasOwn(process, 'env') || 'env' in process)
+  ) {
+    return process.env[envKey];
+  }
+
+  return undefined;
+};