stream-chat 9.50.3 → 10.0.0-rc.2

package/src/uploadManager.ts

@@ -1,8 +1,11 @@
 import type { StreamChat } from './client';
+import { chatLoggerSystem } from './logger';
 import type { UploadRequestOptions } from './messageComposer/configuration/types';
 import { StateStore } from './store';
 import type { AttachmentManager } from '.';
 
+const logger = chatLoggerSystem.getLogger('upload-manager');
+
 export type UploadRecord = {
   id: string;
   uploadProgress?: number;
@@ -150,6 +153,11 @@ export class UploadManager {
         );
         resolvePromise(response);
       } catch (error) {
+        if (!abortController.signal.aborted) {
+          logger
+            .withExtraTags('upload', channelCid)
+            .error(`Upload "${id}" failed.`, { error });
+        }
         rejectPromise(error);
       } finally {
         this.inFlightUploads.delete(id);

package/src/utils/FixedSizeQueueCache.ts

@@ -2,6 +2,7 @@ type Dispose<K, T> = (key: K, value: T) => void;
 /**
  * A cache that stores a fixed number of values in a queue.
  * The most recently added or retrieved value is kept at the front of the queue.
+ *
  * @template K - The type of the keys.
  * @template T - The type of the values.
  */
@@ -20,9 +21,10 @@ export class FixedSizeQueueCache<K, T> {
   }
 
   /**
-   * Adds a new or moves the existing reference to the front of the queue
-   * @param key
-   * @param value
+   * Adds a new entry or moves the existing reference to the front of the queue.
+   *
+   * @param key - The cache key.
+   * @param value - The value to associate with `key`.
    */
   add(key: K, value: T) {
     const index = this.keys.indexOf(key);
@@ -48,8 +50,10 @@ export class FixedSizeQueueCache<K, T> {
   }
 
   /**
-   * Retrieves the value by key.
-   * @param key
+   * Retrieves the value by key without changing its position in the queue.
+   *
+   * @param key - The cache key.
+   * @returns The value, or `undefined` when the key is not cached.
    */
   peek(key: K) {
     const value = this.map.get(key);
@@ -59,7 +63,9 @@ export class FixedSizeQueueCache<K, T> {
 
   /**
    * Retrieves the value and moves it to the front of the queue.
-   * @param key
+   *
+   * @param key - The cache key.
+   * @returns The value, or `undefined` when the key is not cached.
    */
   get(key: K) {
     const foundItem = this.peek(key);

package/src/utils/WithSubscriptions.ts

@@ -1,8 +1,9 @@
 import type { Unsubscribe } from '../store';
 
 /**
- * @private
  * Class to use as a template for subscribable entities.
+ *
+ * @internal
  */
 export abstract class WithSubscriptions {
   private unsubscribeFunctions: Set<Unsubscribe> = new Set();

package/src/utils/concurrency.ts

@@ -16,9 +16,9 @@ type AsyncWrapper<P extends unknown[], T> = (
  * should never run simultaneously: if marked with the same tag, functions
  * will run one after another.
  *
- * @param tag Async functions with the same tag will run serially. Async functions
+ * @param tag - Async functions with the same tag will run serially. Async functions
  * with different tags can run in parallel.
- * @param cb Async function to run.
+ * @param cb - Async function to run.
  * @returns Promise that resolves when async functions returns.
  */
 export const withoutConcurrency = createRunner(wrapWithContinuationTracking);
@@ -32,9 +32,9 @@ export const withoutConcurrency = createRunner(wrapWithContinuationTracking);
  * If an async function is already running and was canceled, it will be notified
  * via an abort signal passed as an argument.
  *
- * @param tag Async functions with the same tag will run serially and are canceled
+ * @param tag - Async functions with the same tag will run serially and are canceled
  * when a new action with the same tag is scheduled.
- * @param cb Async function to run. Receives AbortSignal as the only argument.
+ * @param cb - Async function to run. Receives AbortSignal as the only argument.
  * @returns Promise that resolves when async functions returns. If the function didn't
  * start and was canceled, will resolve with 'canceled'. If the function started to run,
  * it's up to the function to decide how to react to cancelation.

package/src/utils/mergeWith/mergeWith.ts

@@ -6,9 +6,9 @@
  * (objValue, srcValue, key, object, source, stack).
  *
  * @category Object
- * @param object The destination object.
- * @param source A single source object or an array of objects to be merged into the .
- * @param customizer The function to customize assigned values.
+ * @param object - The destination object.
+ * @param source - A single source object or an array of objects to be merged into the .
+ * @param customizer - The function to customize assigned values.
  * @returns Returns `object`.
  * @example
  *

package/src/utils/mergeWith/mergeWithCore.ts

@@ -44,177 +44,162 @@ export const isClassInstance = (value: unknown): boolean => {
   return value.constructor && value.constructor !== Object;
 };
 
+type PairMemo = WeakMap<object, WeakSet<object>>;
+
+function memoHasOrAdd(memo: PairMemo, a: object, b: object): boolean {
+  const set = memo.get(a);
+  if (set && set.has(b)) return true;
+  if (set) set.add(b);
+  else memo.set(a, new WeakSet([b]));
+  return false;
+}
+
 /**
- * Performs a deep comparison between two values to determine if they are equivalent.
- * This is similar to Lodash's isEqual implementation but simplified.
+ * Deep semantic equality with cycle safety and symbol-key support.
+ * Keeps your existing semantics:
+ *  - Dates/RegExps compared by value
+ *  - "Class instances" are treated atomically (unequal unless ===)
+ *  - NaN equals NaN; -0 equals 0 (same as ===)
  */
 export const isEqual = (
   value1: unknown,
   value2: unknown,
-  compareStack = new Set<[unknown, unknown]>(),
-  objectStack1 = new WeakSet<object>(),
-  objectStack2 = new WeakSet<object>(),
+  pairMemo: PairMemo = new WeakMap(),
 ): boolean => {
-  // Handle simple equality cases first
-  if (value1 === value2) return true;
-
-  // If either is null/undefined, they're not equal (already checked ===)
+  if (value1 === value2) return true; // includes -0 === 0
   if (value1 == null || value2 == null) return false;
 
-  // Get the type of both values
-  const type1 = typeof value1;
-  const type2 = typeof value2;
+  const t1 = typeof value1;
+  const t2 = typeof value2;
+  if (t1 !== t2) return false;
 
-  // Different types mean they're not equal
-  if (type1 !== type2) return false;
-
-  // Handle non-object types that need special comparison
-  if (type1 !== 'object') {
-    // Special case for NaN
+  if (t1 !== 'object') {
+    // NaN handling
     // eslint-disable-next-line no-self-compare
-    if (value1 !== value1 && value2 !== value2) return true;
-    return value1 === value2;
+    return value1 !== value1 && value2 !== value2 ? true : value1 === value2;
   }
 
-  // At this point, both values are objects
-  const obj1 = value1 as object;
-  const obj2 = value2 as object;
-
-  // Check for circular references in each object
-  if (objectStack1.has(obj1) || objectStack2.has(obj2)) {
-    // If either object has been seen before, consider them equal
-    // if they're both in a circular reference
-    return objectStack1.has(obj1) && objectStack2.has(obj2);
-  }
+  // Objects
+  const o1 = value1 as object;
+  const o2 = value2 as object;
 
-  // Add objects to their respective stacks
-  objectStack1.add(obj1);
-  objectStack2.add(obj2);
+  // Fast path for tag mismatch
+  const tag1 = Object.prototype.toString.call(o1);
+  const tag2 = Object.prototype.toString.call(o2);
+  if (tag1 !== tag2) return false;
 
-  // Handle Date objects - needs to be before the class instance check
-  if (value1 instanceof Date && value2 instanceof Date) {
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return value1.getTime() === value2.getTime();
+  // Special cases before instance test
+  if (o1 instanceof Date && o2 instanceof Date) {
+    return (o1 as Date).getTime() === (o2 as Date).getTime();
   }
-
-  // Handle RegExp objects - needs to be before the class instance check
-  if (value1 instanceof RegExp && value2 instanceof RegExp) {
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return value1.toString() === value2.toString();
-  }
-
-  // If either is a class instance, use reference equality (already checked above)
-  if (isClassInstance(value1) || isClassInstance(value2)) {
-    // Clean up before returning
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return false;
+  if (o1 instanceof RegExp && o2 instanceof RegExp) {
+    const r1 = o1 as RegExp,
+      r2 = o2 as RegExp;
+    return r1.source === r2.source && r1.flags === r2.flags;
   }
 
-  // Handle arrays
-  const isArray1 = Array.isArray(value1);
-  const isArray2 = Array.isArray(value2);
+  // Handle Set comparison
+  // Two sets are equal if they have the same size and
+  // every value in one has an equivalent value in the
+  // other (using deep equality).
+  // Cannot use the same item for multiple matches in another set.
+  if (value1 instanceof Set && value2 instanceof Set) {
+    if (value1.size !== value2.size) return false;
+    if (memoHasOrAdd(pairMemo, value1, value2)) return true;
+
+    const unmatched = new Set(value2);
+
+    for (const v1 of value1) {
+      let matched = false;
+      for (const v2 of unmatched) {
+        if (isEqual(v1, v2, pairMemo)) {
+          unmatched.delete(v2); // consume the match
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) return false;
+    }
 
-  if (isArray1 !== isArray2) {
-    // Clean up before returning
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return false;
+    return unmatched.size === 0;
   }
 
-  if (isArray1 && isArray2) {
-    const arr1 = value1 as unknown[];
-    const arr2 = value2 as unknown[];
+  // Handle Map comparison
+  if (value1 instanceof Map && value2 instanceof Map) {
+    if (value1.size !== value2.size) return false;
 
-    if (arr1.length !== arr2.length) {
-      // Clean up before returning
-      objectStack1.delete(obj1);
-      objectStack2.delete(obj2);
-      return false;
-    }
+    if (memoHasOrAdd(pairMemo, value1, value2)) return true;
 
-    // Check for circular references in the comparison context
-    const pairKey: [unknown, unknown] = [value1, value2];
-    if (compareStack.has(pairKey)) {
-      // Clean up before returning
-      objectStack1.delete(obj1);
-      objectStack2.delete(obj2);
-      return true;
-    }
-    compareStack.add(pairKey);
-
-    // Compare each element
-    for (let i = 0; i < arr1.length; i++) {
-      if (!isEqual(arr1[i], arr2[i], compareStack, objectStack1, objectStack2)) {
-        compareStack.delete(pairKey);
-        // Clean up before returning
-        objectStack1.delete(obj1);
-        objectStack2.delete(obj2);
-        return false;
-      }
-    }
+    const unmatched = new Set(value2); // tracks entries in map2 not yet matched
 
-    compareStack.delete(pairKey);
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return true;
-  }
+    for (const [k1, v1] of value1) {
+      let matchedEntry: [unknown, unknown] | null = null;
 
-  // Handle plain objects
-  const plainObj1 = value1 as Record<string, unknown>;
-  const plainObj2 = value2 as Record<string, unknown>;
+      for (const entry of unmatched) {
+        const [k2, v2] = entry as [unknown, unknown];
+        if (isEqual(k1, k2, pairMemo) && isEqual(v1, v2, pairMemo)) {
+          matchedEntry = entry;
+          break;
+        }
+      }
 
-  const keys1 = Object.keys(plainObj1);
-  const keys2 = Object.keys(plainObj2);
+      if (!matchedEntry) return false; // nothing matched this entry
+      unmatched.delete(matchedEntry); // consume it
+    }
 
-  // If key counts differ, objects aren't equal
-  if (keys1.length !== keys2.length) {
-    // Clean up before returning
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return false;
+    return unmatched.size === 0;
   }
 
-  // Verify all keys in obj2 are in obj1 (we already checked counts, so this
-  // also ensures all keys in obj1 are in obj2)
-  for (const key of keys2) {
-    if (!Object.prototype.hasOwnProperty.call(plainObj1, key)) {
-      // Clean up before returning
-      objectStack1.delete(obj1);
-      objectStack2.delete(obj2);
-      return false;
+  // Treat non-plain instances atomically (your current rule)
+  if (isClassInstance(o1) || isClassInstance(o2)) return false;
+
+  // Cycle guard (pairwise)
+  if (memoHasOrAdd(pairMemo, o1, o2)) return true;
+
+  // Arrays (respect holes vs undefined)
+  if (Array.isArray(o1)) {
+    const a1 = value1 as unknown[],
+      a2 = value2 as unknown[];
+    if (a1.length !== a2.length) return false;
+    for (let i = 0; i < a1.length; i++) {
+      const has1 = i in a1,
+        has2 = i in a2;
+      if (has1 !== has2) return false;
+      if (has1 && !isEqual(a1[i], a2[i], pairMemo)) return false;
     }
-  }
-
-  // Check for circular references in the comparison context
-  const pairKey: [unknown, unknown] = [value1, value2];
-  if (compareStack.has(pairKey)) {
-    // Clean up before returning
-    objectStack1.delete(obj1);
-    objectStack2.delete(obj2);
-    return true;
-  }
-  compareStack.add(pairKey);
-
-  // Compare each property's value
-  for (const key of keys1) {
-    if (
-      !isEqual(plainObj1[key], plainObj2[key], compareStack, objectStack1, objectStack2)
-    ) {
-      compareStack.delete(pairKey);
-      // Clean up before returning
-      objectStack1.delete(obj1);
-      objectStack2.delete(obj2);
-      return false;
+    // Compare enumerable non-index props as well (to align with objects)
+    const extraKeys1 = Reflect.ownKeys(o1)
+      .filter((k) => typeof k !== 'string' || isNaN(+k))
+      .filter((k) => Object.prototype.propertyIsEnumerable.call(o1, k));
+    const extraKeys2 = Reflect.ownKeys(o2)
+      .filter((k) => typeof k !== 'string' || isNaN(+k))
+      .filter((k) => Object.prototype.propertyIsEnumerable.call(o2, k));
+    if (extraKeys1.length !== extraKeys2.length) return false;
+    for (const k of extraKeys1) {
+      if (!Object.prototype.hasOwnProperty.call(o2, k)) return false;
+      // @ts-expect-error index signature
+      if (!isEqual(o1[k], o2[k], pairMemo)) return false;
     }
+    return true;
   }
 
-  compareStack.delete(pairKey);
-  // Clean up before returning successful comparison
-  objectStack1.delete(obj1);
-  objectStack2.delete(obj2);
+  // Plain objects (string + symbol enumerable own keys)
+  const keys1 = Reflect.ownKeys(o1).filter((k) =>
+    Object.prototype.propertyIsEnumerable.call(o1, k),
+  );
+  const keys2 = Reflect.ownKeys(o2).filter((k) =>
+    Object.prototype.propertyIsEnumerable.call(o2, k),
+  );
+  if (keys1.length !== keys2.length) return false;
+
+  // enforce same prototype to avoid {} == Object.create(null, ...)
+  if (Object.getPrototypeOf(o1) !== Object.getPrototypeOf(o2)) return false;
+
+  for (const k of keys1) {
+    if (!Object.prototype.hasOwnProperty.call(o2, k)) return false;
+    // @ts-expect-error index signature
+    if (!isEqual(o1[k], o2[k], pairMemo)) return false;
+  }
   return true;
 };
 
@@ -241,13 +226,7 @@ function compareAndBuildDiff(
   modified: unknown,
   parentDiffNode: DiffNode,
   key?: string | symbol,
-  /**
-   * Tracks pairs of objects being compared
-   *  - It stores pairs of values that are being compared `[original, modified]`
-   *  - This helps detect when we're comparing the same pair of objects again
-   *  - It prevents infinite recursion when comparing complex object structures
-   */
-  compareStack = new Set<[unknown, unknown]>(),
+  pairMemo: PairMemo = new WeakMap(),
   /**
    * Tracks individual objects that are being processed in the current traversal path
    *  - It's used to detect when we encounter the same object multiple times in a single traversal path
@@ -257,9 +236,7 @@ function compareAndBuildDiff(
   objectStack = new Set<unknown>(),
 ): void {
   // If values are equal, no diff to record
-  if (isEqual(original, modified, new Set(compareStack))) {
-    return;
-  }
+  if (isEqual(original, modified)) return;
 
   // Handle additions (value in modified but not in original)
   if (original === undefined || original === null) {
@@ -335,16 +312,20 @@ function compareAndBuildDiff(
     parentDiffNode.children[String(key)] = currentDiffNode;
   }
 
-  // Check for circular references in comparison
-  const pairKey: [unknown, unknown] = [original, modified];
-  if (compareStack.has(pairKey)) {
-    // Remove from object stack before returning
-    if (typeof original === 'object' && original !== null) {
-      objectStack.delete(original);
+  // Pairwise cycle check (prevents infinite recursion across the *pair*)
+  if (
+    typeof original === 'object' &&
+    original !== null &&
+    typeof modified === 'object' &&
+    modified !== null
+  ) {
+    if (memoHasOrAdd(pairMemo, original as object, modified as object)) {
+      // already visited this exact pair in this diff traversal
+      // (prevents infinite recursion), so stop here
+      if (typeof original === 'object') objectStack.delete(original);
+      return;
     }
-    return;
   }
-  compareStack.add(pairKey);
 
   // Process all keys from both objects
   const allKeys = new Set([
@@ -380,17 +361,12 @@ function compareAndBuildDiff(
       modifiedValue,
       currentDiffNode,
       childKey,
-      compareStack,
+      pairMemo,
       objectStack,
     );
   }
 
-  compareStack.delete(pairKey);
-
-  // Remove from object stack before returning
-  if (typeof original === 'object' && original !== null) {
-    objectStack.delete(original);
-  }
+  if (typeof original === 'object' && original !== null) objectStack.delete(original);
 }
 
 export function createMergeCore<T extends object>(options: { trackDiff?: boolean } = {}) {

package/src/utils/mergeWith/mergeWithDiff.ts

@@ -3,9 +3,9 @@
  * which keys have been added or updated during the merge operation.
  *
  * @category Object
- * @param object The destination object.
- * @param source A single source object or an array of objects to be merged into the object.
- * @param customizer The function to customize assigned values.
+ * @param object - The destination object.
+ * @param source - A single source object or an array of objects to be merged into the object.
+ * @param customizer - The function to customize assigned values.
  * @returns Returns an object containing the merged result and a hierarchical diff object.
  * @example
  *

package/src/utils/retryable.ts

@@ -0,0 +1,117 @@
+type FunctionToRetry<T = any> = (...functionArguments: any[]) => PromiseLike<T>;
+
+enum RetryErrorType {
+  ABORT,
+  ATTEMPT_LIMIT_REACHED,
+}
+
+export class RetryError extends Error {
+  public name = 'RetryError';
+
+  private static errorMap = {
+    [RetryErrorType.ABORT]: 'Value changed, retry handler aborted',
+    [RetryErrorType.ATTEMPT_LIMIT_REACHED]: 'Reached maximum amount of retry attempts',
+  } satisfies Record<RetryErrorType, string>;
+
+  constructor({ type }: { type: RetryErrorType }) {
+    super(RetryError.errorMap[type]);
+  }
+}
+
+export const sleep = (duration: number) =>
+  new Promise((resolve) => setTimeout(resolve, duration));
+
+// export const handleFalsePositiveResponse = <
+//   T extends (...v: any[]) => PromiseLike<SuppliesResponse>,
+// >(
+//   f: T,
+// ) =>
+//   async function falsePositiveHandler(...functionArguments: Parameters<T>) {
+//     // await or throw if "f" fails
+//     const data = (await f(...functionArguments)) as Awaited<ReturnType<T>>;
+//     // check for error data, throw if exist
+//     if (data.errors !== null) {
+//       const stringifiedErrors = data.errors
+//         .map((error, index) => `E${index + 1}(${error.errorCode}): ${error.message}`)
+//         .join('\n');
+
+//       throw new Error(stringifiedErrors);
+//     }
+
+//     return data;
+//   };
+
+export type RunWithRetryOptions<T extends FunctionToRetry> = {
+  retryAttempts?: number;
+  delayBetweenRetries?: number | ((attempt: number) => number);
+  isRetryable?: (error: unknown) => boolean;
+  didValueChange?: (...functionArguments: Parameters<T>) => Promise<boolean> | boolean;
+};
+
+/**
+ * Function which wraps asynchronous functions with retry mechanism which'll keep executing said
+ * function pre-defined number of times until it resolves, rejects or the retry mechanism runs out of available attempts.
+ *
+ * #### Available options:
+ *  - `didValueChange` - check function with initial argument value to check against new values, return `true` to abort next attempt
+ *
+ *  - `isRetryable` - error evaluation function which determines whether to retry the execution
+ *
+ *  - `delayBetweenRetries` - accepts either fixed numeric value or function which provides retry attempt as the argument, expects number as return value
+ *
+ *  - `retryAttempts` - number of attempts to try out before rejecting the promise
+ */
+export const runWithRetry = <T extends FunctionToRetry>(
+  f: T,
+  {
+    retryAttempts = 3,
+    delayBetweenRetries,
+    isRetryable,
+    didValueChange,
+  }: RunWithRetryOptions<T> = {},
+) =>
+  async function retryable(...functionArguments: Parameters<T>) {
+    // starting with -1 as first attempt is not considered a retry
+    let retryAttempt = -1;
+
+    do {
+      let data: Awaited<ReturnType<T>> | null = null;
+      let error: unknown = null;
+
+      if (await didValueChange?.(...functionArguments)) {
+        throw new RetryError({ type: RetryErrorType.ABORT });
+      }
+
+      try {
+        data = await f(...functionArguments);
+      } catch (e) {
+        error = e;
+      }
+
+      // disable value change check after successfull server call
+      // throwing error at this point could lead to stale local states
+
+      // if (await didValueChange?.(...functionArguments)) {
+      //   throw new RetryError({ type: 'abort' });
+      // }
+
+      if (data) return data;
+
+      const runRetry = isRetryable?.(error) ?? true;
+      if (!runRetry) throw error;
+
+      retryAttempt++;
+
+      const isLastAttempt = retryAttempt === retryAttempts;
+
+      if (delayBetweenRetries && !isLastAttempt) {
+        await sleep(
+          typeof delayBetweenRetries === 'function'
+            ? delayBetweenRetries(retryAttempt)
+            : delayBetweenRetries,
+        );
+      }
+    } while (retryAttempt < retryAttempts);
+
+    throw new RetryError({ type: RetryErrorType.ATTEMPT_LIMIT_REACHED });
+  };