@ethora/chat-component-rn 26.10.4 → 26.10.6

package/src/helpers/attachments.ts

@@ -0,0 +1,316 @@
+import { IAttachment, IMessage } from '../types/types';
+import { safeJsonParse } from './safeJson';
+import { repairFilenameEncoding } from './repairFilenameEncoding';
+import { inferMimeFromName, isGenericMime } from './mimeToExtension';
+
+/** Parses a dimension that may arrive as a number or a numeric string. */
+const parseDimension = (value: unknown): number | undefined => {
+  const n = typeof value === 'string' ? Number.parseFloat(value) : value;
+  return typeof n === 'number' && Number.isFinite(n) && n > 0 ? n : undefined;
+};
+
+/**
+ * Hard ceiling on how many attachments we will serialise into a stanza.
+ * The composer caps the picker far below this; this is the parser-side
+ * guard so a malformed or hostile stanza cannot make us render an
+ * unbounded grid.
+ */
+export const MAX_ATTACHMENTS_PER_MESSAGE = 10;
+
+const asOptionalString = (value: unknown): string | undefined => {
+  if (value === null || value === undefined) return undefined;
+  if (typeof value === 'string') return value || undefined;
+  if (typeof value === 'number') return String(value);
+  return undefined;
+};
+
+/** A file name from the wire/API, with UTF-8-read-as-Latin-1 mojibake undone. */
+const asOptionalFileName = (value: unknown): string | undefined => {
+  const name = asOptionalString(value);
+  return name === undefined ? undefined : repairFilenameEncoding(name);
+};
+
+const asOptionalBoolean = (value: unknown): boolean | undefined => {
+  if (typeof value === 'boolean') return value;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return undefined;
+};
+
+/**
+ * Turns one raw wire/API object into an `IAttachment`, or null when there is
+ * nothing renderable in it. `location` is allowed to be empty: that is what
+ * an optimistic (still-uploading) attachment looks like.
+ */
+export const normalizeAttachment = (raw: unknown): IAttachment | null => {
+  if (!raw || typeof raw !== 'object') return null;
+
+  const source = raw as Record<string, unknown>;
+  const location = asOptionalString(source.location) ?? '';
+  const originalName =
+    asOptionalFileName(source.originalName) ?? asOptionalFileName(source.originalname);
+  const rawMimetype = asOptionalString(source.mimetype);
+  const fileName = asOptionalFileName(source.fileName) ?? asOptionalFileName(source.filename);
+  const duration =
+    asOptionalString(source.duration) ?? asOptionalString(source.mediaDuration);
+  const mimetype = resolveLegacyMimetype(rawMimetype, {
+    names: [originalName, fileName, urlPath(location)],
+    duration,
+  });
+
+  if (!location && !originalName && !mimetype && !fileName) {
+    return null;
+  }
+
+  return {
+    attachmentId: asOptionalString(source.attachmentId) ?? asOptionalString(source._id),
+    location,
+    locationPreview: asOptionalString(source.locationPreview),
+    mimetype,
+    originalName,
+    fileName,
+    size: asOptionalString(source.size),
+    duration,
+    ...optionalDimensions(source),
+    ownerKey: asOptionalString(source.ownerKey),
+    userId: asOptionalString(source.userId),
+    createdAt: asOptionalString(source.createdAt),
+    updatedAt: asOptionalString(source.updatedAt),
+    expiresAt: asOptionalString(source.expiresAt),
+    isVisible: asOptionalBoolean(source.isVisible),
+    isPrivate: asOptionalBoolean(source.isPrivate),
+    ...normalizeUploadState(source),
+  };
+};
+
+/** The path part of a URL (no query or fragment), for reading an extension off it. */
+const urlPath = (url: string): string | undefined =>
+  url ? url.split(/[?#]/)[0] : undefined;
+
+/**
+ * Older clients and the storage send media with no `mimetype`, or with the
+ * "could not sniff" `application/octet-stream`. The extension of any name the
+ * file carries tells which picture, video, audio or PDF it is. A nameless or
+ * extensionless file with a duration is a recorded voice note (browsers upload
+ * those as a `blob`), which is exactly what octet-stream renders as.
+ */
+const resolveLegacyMimetype = (
+  mimetype: string | undefined,
+  hints: { names: Array<string | undefined>; duration?: string }
+): string | undefined => {
+  if (!isGenericMime(mimetype)) return mimetype;
+  const hasDuration = Number.parseFloat(hints.duration ?? '') > 0;
+  // A recorded note keeps its generic type: browsers upload it as a nameless
+  // `blob` (and storage may add a `.webm` to the stored name, which is audio
+  // here, not video). Only a name that says what it is overrides that.
+  if (hasDuration && !inferMimeFromName(hints.names[0])) return mimetype ?? 'application/octet-stream';
+  for (const name of hints.names) {
+    const inferred = inferMimeFromName(name);
+    if (inferred) return inferred;
+  }
+  return mimetype;
+};
+
+/** Pixel size, only when the source carries a usable one. */
+const optionalDimensions = (
+  source: Record<string, unknown>
+): Pick<IAttachment, 'width' | 'height'> => {
+  const width = parseDimension(source.width);
+  const height = parseDimension(source.height);
+  return {
+    ...(width !== undefined ? { width } : {}),
+    ...(height !== undefined ? { height } : {}),
+  };
+};
+
+/**
+ * Local upload state rides along on optimistic attachments only; it is
+ * never serialised, so a received attachment never carries it.
+ */
+const normalizeUploadState = (
+  source: Record<string, unknown>
+): Pick<IAttachment, 'uploadStatus' | 'uploadProgress' | 'localUrl'> => {
+  const status = source.uploadStatus === 'uploading' || source.uploadStatus === 'failed'
+    ? source.uploadStatus
+    : undefined;
+  if (!status) return {};
+  const progress =
+    typeof source.uploadProgress === 'number' && Number.isFinite(source.uploadProgress)
+      ? Math.min(100, Math.max(0, source.uploadProgress))
+      : 0;
+  // Only a file on this device can be the local preview of an outgoing file.
+  const localUrl =
+    typeof source.localUrl === 'string' && /^(file|content):\/\//.test(source.localUrl)
+      ? source.localUrl
+      : undefined;
+  return {
+    uploadStatus: status,
+    uploadProgress: progress,
+    ...(localUrl ? { localUrl } : {}),
+  };
+};
+
+/** Accepts the parsed array, the raw JSON string, or junk. Never throws. */
+export const parseAttachments = (raw: unknown): IAttachment[] => {
+  const candidate = typeof raw === 'string' ? safeJsonParse<unknown>(raw, []) : raw;
+  if (!Array.isArray(candidate)) return [];
+
+  return candidate
+    .slice(0, MAX_ATTACHMENTS_PER_MESSAGE)
+    .map(normalizeAttachment)
+    .filter((item): item is IAttachment => item !== null);
+};
+
+/**
+ * The wire form: a JSON string on the `<data attachments="...">` attribute.
+ * Only the fields a receiver renders are sent - the stanza is already wide
+ * and every byte here is duplicated per attachment.
+ */
+export const serializeAttachments = (attachments: IAttachment[]): string =>
+  JSON.stringify(
+    attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE).map((attachment) => ({
+      attachmentId: attachment.attachmentId,
+      location: attachment.location,
+      locationPreview: attachment.locationPreview,
+      mimetype: attachment.mimetype,
+      originalName: attachment.originalName,
+      fileName: attachment.fileName,
+      size: attachment.size,
+      duration: attachment.duration,
+    }))
+  );
+
+/**
+ * The only supported way to read a media message's files.
+ *
+ * Order of truth: the multi-attach payload when present, otherwise the flat
+ * legacy fields synthesised into a single attachment. Every message that
+ * predates this feature - and every message from a client that does not
+ * speak it - takes the second path.
+ */
+export const getMessageAttachments = (
+  message?: Pick<
+    IMessage,
+    | 'attachments'
+    | 'location'
+    | 'locationPreview'
+    | 'mimetype'
+    | 'originalName'
+    | 'fileName'
+    | 'size'
+  > & { duration?: unknown; mediaDuration?: unknown } | null
+): IAttachment[] => {
+  if (!message) return [];
+
+  const parsed = parseAttachments(message.attachments);
+  if (parsed.length > 0) return parsed;
+
+  // Legacy clients may pack several files into the flat fields as a
+  // comma separated list of URLs; the other flat fields then list one value
+  // each, in the same order, or one value for all.
+  const locations = splitUrlList(message.location);
+  if (locations.length > 1) {
+    const previews = splitUrlList(message.locationPreview);
+    const mimetypes = splitList(message.mimetype);
+    const names = splitList(message.originalName);
+    return locations
+      .slice(0, MAX_ATTACHMENTS_PER_MESSAGE)
+      .map((location, index) =>
+        normalizeAttachment({
+          location,
+          locationPreview: previews.length === locations.length ? previews[index] : undefined,
+          mimetype: pickNth(mimetypes, index, locations.length),
+          originalName: pickNth(names, index, locations.length),
+          size: undefined,
+        })
+      )
+      .filter((item): item is IAttachment => item !== null);
+  }
+
+  const legacy = normalizeAttachment({
+    location: message.location,
+    locationPreview: message.locationPreview,
+    mimetype: message.mimetype,
+    originalName: message.originalName,
+    fileName: message.fileName,
+    size: message.size,
+    duration: message.duration,
+    mediaDuration: message.mediaDuration,
+  });
+
+  return legacy ? [legacy] : [];
+};
+
+/** "https://a/x.jpg, https://a/y.jpg" -> two URLs. A single URL stays whole, commas and all. */
+const splitUrlList = (value: unknown): string[] =>
+  typeof value === 'string' && /,\s*https?:\/\//i.test(value)
+    ? value.split(/,\s*(?=https?:\/\/)/i).map((item) => item.trim()).filter(Boolean)
+    : typeof value === 'string' && value
+      ? [value]
+      : [];
+
+const splitList = (value: unknown): string[] =>
+  typeof value === 'string' && value ? value.split(',').map((item) => item.trim()) : [];
+
+/** The nth entry of a parallel list, or its only entry when it is shared by all. */
+const pickNth = (list: string[], index: number, total: number): string | undefined =>
+  list.length === total ? list[index] : list.length === 1 ? list[0] : undefined;
+
+/**
+ * True when the message carries a file: flagged `isMediafile`, or (older
+ * senders that never set the flag) with a real file URL or attachment. The
+ * one test every surface uses for "is this a media bubble".
+ */
+export const isMediaMessage = (
+  message?:
+    | (Partial<Pick<IMessage, 'isDeleted' | 'isMediafile' | 'attachments'>> & {
+        location?: unknown;
+        mimetype?: unknown;
+        originalName?: unknown;
+        fileName?: unknown;
+        locationPreview?: unknown;
+      })
+    | null
+): boolean => {
+  if (!message || message.isDeleted) return false;
+  if (String(message.isMediafile) === 'true') return true;
+  return getMessageAttachments(message as never).some(
+    (attachment) => Boolean(attachment.location)
+  );
+};
+
+/**
+ * Maps one object from POST /files/ `results` to the attachment a sent
+ * message carries. Field names here follow the API's own spelling
+ * (`originalname`, `filename`), not the wire attribute names.
+ */
+export const toUploadedAttachment = (raw: any): IAttachment => ({
+  attachmentId: raw?._id,
+  location: raw?.location,
+  locationPreview: raw?.locationPreview,
+  mimetype: raw?.mimetype,
+  originalName:
+    typeof raw?.originalname === 'string'
+      ? repairFilenameEncoding(raw.originalname)
+      : raw?.originalname,
+  fileName:
+    typeof raw?.filename === 'string'
+      ? repairFilenameEncoding(raw.filename)
+      : raw?.filename,
+  size: raw?.size?.toString?.() ?? raw?.size,
+  duration: raw?.duration,
+  ownerKey: raw?.ownerKey,
+  userId: raw?.userId,
+  createdAt: raw?.createdAt,
+  updatedAt: raw?.updatedAt,
+  expiresAt: raw?.expiresAt,
+  isVisible: raw?.isVisible,
+  isPrivate: raw?.isPrivate,
+});
+
+/** Name to show for an attachment, with the URL tail as the last resort. */
+export const getAttachmentName = (attachment: IAttachment): string =>
+  attachment.originalName ||
+  attachment.fileName ||
+  attachment.location?.split('/')?.pop() ||
+  'MediaFile';

package/src/helpers/caption.ts

@@ -0,0 +1,283 @@
+import { IMentionSpan } from '../types/types';
+import { safeJsonParse } from './safeJson';
+import { validateMentionSpans } from './mentionSpans';
+import { getAttachmentName, getMessageAttachments, isMediaMessage } from './attachments';
+
+/**
+ * The text typed with a set of attachments, sent as part of the media
+ * message itself (never as a separate text stanza).
+ *
+ * `mentions` index into `text`, the same way a text message's mention spans
+ * index into its body.
+ */
+export interface CaptionInput {
+  text: string;
+  mentions?: IMentionSpan[];
+}
+
+export interface NormalizedCaption {
+  caption: string;
+  mentions?: IMentionSpan[];
+}
+
+const isSpanShape = (value: unknown): value is IMentionSpan => {
+  if (!value || typeof value !== 'object') return false;
+  const span = value as Record<string, unknown>;
+  return (
+    typeof span.jid === 'string' &&
+    typeof span.name === 'string' &&
+    typeof span.offset === 'number' &&
+    Number.isInteger(span.offset) &&
+    typeof span.length === 'number' &&
+    Number.isInteger(span.length)
+  );
+};
+
+/**
+ * Mention spans for a caption, checked against the caption text: a span that
+ * no longer reads "@Name" at its offset is dropped. Undefined when nothing is
+ * left, so a caption without mentions carries no empty attribute.
+ */
+export const normalizeCaptionMentions = (
+  value: unknown,
+  caption: string
+): IMentionSpan[] | undefined => {
+  const parsed =
+    typeof value === 'string' ? safeJsonParse<unknown>(value, []) : value;
+  if (!Array.isArray(parsed)) return undefined;
+  const spans = validateMentionSpans(caption, parsed.filter(isSpanShape));
+  return spans.length > 0 ? spans : undefined;
+};
+
+/**
+ * Turns what the composer typed into the caption that travels with the
+ * media. Undefined for blank text, which means "no caption".
+ */
+export const normalizeCaptionInput = (
+  input?: CaptionInput | null
+): NormalizedCaption | undefined => {
+  const text = typeof input?.text === 'string' ? input.text : '';
+  if (!/\S/.test(text)) return undefined;
+  const mentions = normalizeCaptionMentions(input?.mentions, text);
+  return mentions ? { caption: text, mentions } : { caption: text };
+};
+
+/** What a media message's text is, and the @-mention spans that index into it. */
+export interface ResolvedCaption {
+  text: string;
+  mentions?: IMentionSpan[];
+}
+
+export interface CaptionOptions {
+  /**
+   * The caller already knows this is a media message (a thin `lastMessage`
+   * that only says so by its id). Otherwise it is read off the message.
+   */
+  isMedia?: boolean;
+  /** The message is sealed: only a caption that came out of the envelope counts. */
+  sealed?: boolean;
+  /** Extra names of the sender, which a body may merely echo. */
+  senderNames?: string[];
+}
+
+/**
+ * Bodies that are not something a person typed: the media placeholder every
+ * SDK sends, and the labels apps generate for a file with nothing to say.
+ */
+const PLACEHOLDER_BODIES = new Set([
+  'media',
+  'attachment',
+  'attachments',
+  'photo',
+  'photos',
+  'image',
+  'images',
+  'picture',
+  'video',
+  'audio',
+  'voice',
+  'voice message',
+  'voice note',
+  'file',
+  'files',
+  'document',
+  'blob',
+  'undefined',
+  'null',
+  '[object object]',
+]);
+
+/** `<data>` attributes older or foreign clients stamp the file's text on. */
+const CAPTION_ALIASES = ['captionText', 'text', 'message', 'description', 'title'] as const;
+
+const norm = (value: unknown): string =>
+  typeof value === 'string' ? value.trim().toLowerCase() : '';
+
+const str = (value: unknown): string =>
+  typeof value === 'string' ? value : typeof value === 'number' ? String(value) : '';
+
+const tail = (url: string): string => {
+  const path = url.split(/[?#]/)[0];
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+
+const safeDecode = (value: string): string => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+
+/** Every string a media message's `body` is allowed to merely repeat. */
+const echoCandidates = (
+  message: Record<string, any>,
+  options: CaptionOptions
+): Set<string> => {
+  const out = new Set<string>();
+  const add = (value: unknown) => {
+    const v = norm(value);
+    if (v) out.add(v);
+  };
+
+  // The file itself: its names and its URLs, as sent and as stored.
+  const attachments = getMessageAttachments(message as never);
+  for (const attachment of attachments) {
+    add(getAttachmentName(attachment));
+    add(attachment.originalName);
+    add(attachment.fileName);
+    for (const url of [attachment.location, attachment.locationPreview]) {
+      if (!url) continue;
+      add(url);
+      add(safeDecode(url));
+      add(tail(url));
+      add(safeDecode(tail(url)));
+    }
+  }
+  add(message.originalName);
+  add(message.fileName);
+  add(message.location);
+  add(message.locationPreview);
+
+  // The sender: some clients put their own name, e-mail or username in the
+  // body next to the file.
+  const user = (message.user ?? {}) as Record<string, unknown>;
+  const first = str(message.senderFirstName) || str(message.firstName) || str(user.firstName);
+  const last = str(message.senderLastName) || str(message.lastName) || str(user.lastName);
+  add(user.name);
+  add(`${first} ${last}`);
+  add(first && !last ? first : '');
+  add(user.email);
+  add(user.username);
+  add(message.email);
+  add(message.userName);
+  add(message.username);
+  add(message.senderName);
+  const idLocal = str(user.id).split('@')[0];
+  add(idLocal);
+  add(str(user.id).split('_').pop());
+  add(str(message.senderJID).split('/')[0].split('@')[0]);
+  for (const name of options.senderNames ?? []) add(name);
+  return out;
+};
+
+/** "etest etest" is echoed as "etest": every word of the name is the body. */
+const isRepeatedName = (name: string, text: string): boolean =>
+  Boolean(name && text) && name.split(/\s+/).every((part) => part === text);
+
+const isRealCaptionText = (
+  text: string,
+  message: Record<string, any>,
+  options: CaptionOptions
+): boolean => {
+  const t = text.trim();
+  if (!t) return false;
+  const n = t.toLowerCase();
+  if (PLACEHOLDER_BODIES.has(n)) return false;
+  // The key envelope a sealed message carries in its body is never text.
+  if (/^\{\s*"v"\s*:\s*\d+\s*,\s*"keys"/.test(t)) return false;
+  const candidates = echoCandidates(message, options);
+  if (candidates.has(n)) return false;
+  for (const name of candidates) if (isRepeatedName(name, n)) return false;
+  return true;
+};
+
+const asRecord = (message: unknown): Record<string, any> | undefined =>
+  message && typeof message === 'object' ? (message as Record<string, any>) : undefined;
+
+const resolveSpans = (
+  message: Record<string, any>,
+  text: string,
+  keys: string[]
+): IMentionSpan[] | undefined => {
+  for (const key of keys) {
+    const spans = normalizeCaptionMentions(message[key] ?? message.data?.[key], text);
+    if (spans) return spans;
+  }
+  return undefined;
+};
+
+/**
+ * The text of a media message, from whichever format carried it. The one
+ * place that knows the formats, so every surface (bubble, room list preview,
+ * notification, reply quote, copy) agrees:
+ *
+ *  1. `caption` (+ `captionMentions`): what this SDK sends. The only source
+ *     for a sealed message, whose caption comes out of the envelope.
+ *  2. The caption under another name on `<data>` (`captionText`, `text`,
+ *     `message`, `description`, `title`) from other clients.
+ *  3. A real `body`: older clients and other SDKs put the text in the
+ *     `<body>` of the media message itself. "media", the file's name or URL,
+ *     the sender's own name or e-mail and generated labels are not text.
+ *
+ * Never derived for a sealed message, and never for a message with no file.
+ */
+export const resolveMessageCaption = (
+  message?: object | null,
+  options: CaptionOptions = {}
+): ResolvedCaption | undefined => {
+  const source = asRecord(message);
+  if (!source || source.isDeleted) return undefined;
+
+  const explicit = source.caption;
+  if (typeof explicit === 'string' && /\S/.test(explicit)) {
+    const mentions = normalizeCaptionMentions(source.captionMentions, explicit);
+    return mentions ? { text: explicit, mentions } : { text: explicit };
+  }
+
+  const sealed =
+    options.sealed === true ||
+    source.clientEncrypted === 'true' ||
+    (Array.isArray(source.e2eeKeys) && source.e2eeKeys.length > 0);
+  if (sealed) return undefined;
+
+  const isMedia = options.isMedia ?? isMediaMessage(source as never);
+  if (!isMedia) return undefined;
+
+  for (const key of CAPTION_ALIASES) {
+    const value = str(source[key] ?? source.data?.[key]);
+    if (value && isRealCaptionText(value, source, options)) {
+      const mentions = resolveSpans(source, value, ['captionMentions']);
+      return mentions ? { text: value, mentions } : { text: value };
+    }
+  }
+
+  const body = str(source.body);
+  if (body && isRealCaptionText(body, source, options)) {
+    const mentions = resolveSpans(source, body, ['mentions']);
+    return mentions ? { text: body, mentions } : { text: body };
+  }
+  return undefined;
+};
+
+/** The caption a message carries, or undefined when it has none. */
+export const getMessageCaption = (
+  message?: object | null,
+  options?: CaptionOptions
+): string | undefined => resolveMessageCaption(message, options)?.text;
+
+/** The mention spans of `getMessageCaption`'s text. */
+export const getMessageCaptionMentions = (
+  message?: object | null,
+  options?: CaptionOptions
+): IMentionSpan[] | undefined => resolveMessageCaption(message, options)?.mentions;

package/src/helpers/createMainMessageForThread.ts

@@ -1,8 +1,13 @@
 import { IMessage } from '../types/types';
+import { getMessageCaption } from './caption';
 
 export const createMainMessageForThread = (message: IMessage): string => {
+  // A media message is quoted by its caption. A sealed one never is: the
+  // reply stanza travels in the clear, the caption does not.
+  const caption =
+    message.clientEncrypted === 'true' ? undefined : getMessageCaption(message);
   const data = {
-    text: message.body,
+    text: caption ?? message.body,
     id: message.id,
     userName: message.user.name,
     createdAt: message.date,

package/src/helpers/createMessageFromXml.ts

@@ -1,7 +1,8 @@
 import { IMessage } from '../types/types';
 import { isE2eeRoom } from '../e2ee';
 import { composeName } from './displayName';
-import { parseSealedMediaBody } from '../e2ee/sealedBody';
+import { parseSealedMediaPayload } from '../e2ee/sealedBody';
+import { normalizeMediaDataAttrs } from './mediaWireData';
 
 interface IMessageWithNewData extends IMessage {
   [x: string]: any;
@@ -66,7 +67,9 @@ export const createMessageFromXml = async (
   }
 
   const merged: any = {
-    ...inner,
+    // Idempotent: the wrapped path already ran it in getDataFromXml, the
+    // positional (MAM catch-up) path hands over the raw attrs.
+    ...normalizeMediaDataAttrs(inner),
     ...outerExtras,
     isDeleted: !!outerExtras?.deleted || !!(arg as any)?.isDeleted,
   };
@@ -140,15 +143,28 @@ export const createMessageFromXml = async (
   const unencrypted =
     merged.omemoEncrypted !== 'true' && isE2eeRoom(String(merged.roomJid || ''));
 
-  const sealedKeys =
+  // A sealed media body is `{v:1,keys,caption?,captionMentions?}`. The keys
+  // and the caption are lifted next to each other; the caption is the only
+  // one a sealed message may show (any open caption attribute was dropped
+  // by normalizeMediaDataAttrs).
+  const sealed =
     merged.clientEncrypted === 'true'
-      ? parseSealedMediaBody(merged.body)
+      ? parseSealedMediaPayload(merged.body)
       : undefined;
 
   const message: IMessage = {
     ...merged,
     ...(unencrypted ? { unencrypted: true } : {}),
-    ...(sealedKeys ? { e2eeKeys: sealedKeys, body: 'media' } : {}),
+    ...(sealed
+      ? {
+          e2eeKeys: sealed.keys,
+          body: 'media',
+          ...(sealed.caption ? { caption: sealed.caption } : {}),
+          ...(sealed.captionMentions
+            ? { captionMentions: sealed.captionMentions }
+            : {}),
+        }
+      : {}),
     user: {
       ...(merged.user || {}),
       id: merged?.user?.id || fromResource || senderLocal,