stream-chat 9.51.0 → 9.52.1

package/src/utils.ts

@@ -1,6 +1,7 @@
 import FormData from 'form-data';
 import type {
   AscDesc,
+  Attachment,
   ChannelFilters,
   ChannelQueryOptions,
   ChannelSort,
@@ -40,6 +41,36 @@ export function logChatPromiseExecution<T>(promise: Promise<T>, name: string) {
   });
 }
 
+/**
+ * The default no-op client logger.
+ */
+export const noopLogger: Logger = () => null;
+
+const logError = <T>(logger: Logger, error: unknown, event: T) => {
+  const message = 'Unhandled error in event listener';
+  logger('error', message, { error, event });
+  if (logger === noopLogger) console.error(message, error, event);
+};
+
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener cannot
+ * abort the dispatch loop or the bookkeeping that follows it.
+ */
+export const invokeEventListener = <T>(
+  listener: (event: T) => unknown,
+  event: T,
+  logger: Logger,
+) => {
+  try {
+    const result = listener(event);
+    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
+      Promise.resolve(result).catch((error) => logError(logger, error, event));
+    }
+  } catch (error) {
+    logError(logger, error, event);
+  }
+};
+
 export const sleep = (m: number): Promise<void> => new Promise((r) => setTimeout(r, m));
 
 export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
@@ -125,13 +156,6 @@ export const channelTracksReadLocally = (channel?: Channel) =>
   !channelHasReadEvents(channel) &&
   !!channel?.getClient().options.isLocalUnreadCountEnabled;
 
-/**
- * userHasReadReceipts - Whether the current user allows read receipts, per their privacy settings.
- * Read receipts are treated as enabled unless the user has explicitly disabled them.
- */
-export const userHasReadReceipts = (client: StreamChat) =>
-  client.user?.privacy_settings?.read_receipts?.enabled ?? true;
-
 export function addFileToFormData(
   uri: string | NodeJS.ReadableStream | Buffer | File,
   name?: string,
@@ -382,6 +406,77 @@ export function unformatMessage(message: LocalMessage): MessageResponse {
   } as MessageResponse;
 }
 
+/**
+ * Whether a URL points at something the API and other devices can actually fetch.
+ */
+const isRemoteUrl = (url?: string) => !!url && /^https?:\/\//i.test(url.trim());
+
+/**
+ * Strips composer-internal state from a message's attachments, and drops any whose upload never
+ * resolved.
+ *
+ * `localMetadata` is how `AttachmentManager` tracks an upload (its id, the `File`, the local
+ * preview); it must never reach the API. An attachment that still carries it and has no remote
+ * URL was never settled — which is what happens when
+ * `createSendWithPendingUploadsAttachmentsMiddleware` is installed by a UI SDK that does not
+ * implement the rest of the flow (awaiting those uploads before sending). Sending it would store
+ * an attachment pointing at nothing, so it is dropped and logged instead.
+ *
+ * Returns the same message object when there was nothing to change.
+ */
+export const sanitizeOutgoingAttachments = <T extends { attachments?: Attachment[] }>({
+  client,
+  message,
+}: {
+  client: StreamChat;
+  message: T;
+}): T => {
+  const attachments = message.attachments;
+  if (!attachments?.length) return message;
+
+  const unresolved: Attachment[] = [];
+  let changed = false;
+
+  const sanitized = attachments.reduce<Attachment[]>((acc, attachment) => {
+    const { localMetadata, ...rest } = attachment as Attachment & {
+      localMetadata?: Record<string, unknown>;
+    };
+
+    if (!localMetadata) {
+      acc.push(attachment);
+      return acc;
+    }
+
+    changed = true;
+
+    // Any of these pointing at a remote URL means the attachment resolved to something the API
+    // can store and other devices can load.
+    const hasRemoteSource =
+      isRemoteUrl(rest.asset_url) ||
+      isRemoteUrl(rest.image_url) ||
+      isRemoteUrl(rest.og_scrape_url) ||
+      isRemoteUrl(rest.title_link);
+
+    if (hasRemoteSource) {
+      acc.push(rest as Attachment);
+    } else {
+      unresolved.push(rest as Attachment);
+    }
+
+    return acc;
+  }, []);
+
+  if (unresolved.length) {
+    const text = `Dropped ${unresolved.length} attachment(s) whose upload never completed. Composing with pending uploads requires awaiting them before sending.`;
+    const extraData = { attachments: unresolved, message, tags: ['attachments'] };
+
+    client.logger('warn', text, extraData);
+    console.warn(text, extraData);
+  }
+
+  return changed ? { ...message, attachments: sanitized } : message;
+};
+
 export const localMessageToNewMessagePayload = (localMessage: LocalMessage): Message => {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   const {