@droppii-org/chat-mobile 0.2.51 → 0.2.52

package/src/services/resourceCenter.ts

@@ -0,0 +1,137 @@
+import { apiInstance } from './apis';
+import { getApiEndpoint } from '../config/api-endpoints';
+import { extractDomain } from '../utils/url';
+import type { BaseResponse } from '../types/auth';
+import {
+  DThreadResourceContentType,
+  type DThreadResource,
+  type DThreadResourceListResponse,
+  type DThreadResourceRawRow,
+  type DThreadResourceRequest,
+} from '../types/chat';
+
+interface RawPicture {
+  url?: string;
+}
+
+interface RawPictureContent {
+  bigPicture?: RawPicture;
+  snapshotPicture?: RawPicture;
+}
+
+interface RawUrlTextEx {
+  urlMetadata?: {
+    title?: string;
+    description?: string;
+    image?: string;
+    url?: string;
+  };
+}
+
+// Confirmed real: `ex.urlMetadata` is sometimes absent entirely (link preview never
+// resolved by BE) — `content.urls[0]` (the raw URL from the message text) is the
+// fallback so the row still has something to display/open.
+interface RawUrlTextContent {
+  urls?: string[];
+}
+
+// FILE/VIDEO shapes verified 2026-07-26 against a real staging response (a 1-1
+// thread, recvID = peer userID) — matched the originally-assumed OpenIM
+// `fileElem`/`videoElem`-style field names exactly.
+interface RawFileContent {
+  fileName?: string;
+  fileSize?: number;
+  fileType?: string;
+  sourceUrl?: string;
+}
+
+interface RawVideoContent {
+  videoUrl?: string;
+  snapshotUrl?: string;
+  duration?: number;
+}
+
+const safeJsonParse = <T>(raw: string | undefined): T | undefined => {
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return undefined;
+  }
+};
+
+const parseThreadResourceItem = (
+  row: DThreadResourceRawRow
+): DThreadResource => {
+  const { chatLog } = row;
+  const contentType = chatLog.contentType as DThreadResourceContentType;
+  const base: DThreadResource = {
+    id: chatLog.clientMsgID,
+    contentType,
+    isRevoked: row.isRevoked,
+    createdAt: chatLog.sendTime,
+  };
+
+  switch (contentType) {
+    case DThreadResourceContentType.IMAGE: {
+      const content = safeJsonParse<RawPictureContent>(chatLog.content);
+      return {
+        ...base,
+        sourceUrl: content?.bigPicture?.url,
+        thumbnailUrl: content?.snapshotPicture?.url,
+      };
+    }
+    case DThreadResourceContentType.VIDEO: {
+      const content = safeJsonParse<RawVideoContent>(chatLog.content);
+      return {
+        ...base,
+        sourceUrl: content?.videoUrl,
+        thumbnailUrl: content?.snapshotUrl,
+        duration: content?.duration,
+      };
+    }
+    case DThreadResourceContentType.FILE: {
+      const content = safeJsonParse<RawFileContent>(chatLog.content);
+      return {
+        ...base,
+        sourceUrl: content?.sourceUrl,
+        fileName: content?.fileName,
+        fileSize: content?.fileSize,
+        mimeType: content?.fileType,
+      };
+    }
+    case DThreadResourceContentType.URL_TEXT: {
+      const ex = safeJsonParse<RawUrlTextEx>(chatLog.ex);
+      const content = safeJsonParse<RawUrlTextContent>(chatLog.content);
+      const metadata = ex?.urlMetadata;
+      const linkUrl = metadata?.url ?? content?.urls?.[0];
+      return {
+        ...base,
+        linkUrl,
+        linkTitle: metadata?.title,
+        linkDescription: metadata?.description,
+        linkImageUrl: metadata?.image,
+        linkDomain: linkUrl ? extractDomain(linkUrl) : undefined,
+      };
+    }
+    default:
+      return base;
+  }
+};
+
+export namespace ResourceCenterService {
+  export const fetchThreadResources = async (
+    req: DThreadResourceRequest
+  ): Promise<{ items: DThreadResource[]; page: number; hasMore: boolean }> => {
+    const res = await apiInstance?.post<
+      BaseResponse<DThreadResourceListResponse>
+    >(getApiEndpoint('messagesResources'), req);
+    const rows = res?.data?.data ?? [];
+    const items = rows.map(parseThreadResourceItem);
+    // `pageable.totalPages`/`totalElements` come back as `0` on this endpoint even
+    // when rows are present (confirmed against staging) — unreliable, don't use it.
+    // Item-count-vs-pageSize is the only trustworthy `hasMore` signal available.
+    const hasMore = items.length >= req.pageSize;
+    return { items, page: req.page, hasMore };
+  };
+}

package/src/translation/resources/i18n.ts

@@ -93,6 +93,13 @@ const i18nKey: Record<string, string> = {
   'yourself': 'chính mình',
   'you': 'Bạn',
   'recent': 'Gần đây',
+  'chat:resource_center_title': 'Tập tin phương tiện',
+  'chat:resource_center_tab_image': 'Ảnh',
+  'chat:resource_center_tab_video': 'Video',
+  'chat:resource_center_tab_file': 'Tập tin',
+  'chat:resource_center_tab_link': 'Liên kết',
+  'chat:resource_center_empty_generic': 'Không tìm thấy tập tin nào',
+  'chat:resource_center_empty_link': 'Không tìm thấy liên kết nào',
 };
 
 export default {

package/src/types/attachment.ts

@@ -1,3 +1,5 @@
+import type { DChatApplicationType } from './chat';
+
 export type AttachmentType = 'image' | 'video' | 'file' | 'audio' | 'document';
 
 export interface BaseAttachment {
@@ -70,6 +72,7 @@ export type BatchStrategy = 'individual' | 'merged' | 'grouped';
 
 export interface AttachmentSendOptions {
   strategy: BatchStrategy;
+  applicationType?: DChatApplicationType;
   includeCaption?: string;
   uploadConcurrency?: number;
   retryFailedUploads?: boolean;

package/src/types/chat.ts

@@ -242,3 +242,76 @@ export type CustomElemOrderData = {
 export type CustomMessagePayload =
   | { type: typeof CustomMessageType.Order; data: CustomElemOrderData }
   | { type: typeof CustomMessageType.Product; data: Record<string, unknown> };
+
+export enum DThreadResourceContentType {
+  IMAGE = 102,
+  VIDEO = 104,
+  FILE = 105,
+  URL_TEXT = 160,
+}
+
+export interface DThreadResourceRequest {
+  // ⚠️ U4c: confirmed working for BOTH shapes — a bot/group thread using the
+  // groupID-shaped value (`bot_<uuid>_<uuid>`, chatLog.groupID echoes it back,
+  // chatLog.recvID empty), AND a plain 1-1 thread using the peer's userID
+  // (matches this repo's own `getReceiverId()` convention exactly — chatLog.recvID
+  // echoes it back, chatLog.groupID empty). U4c fully resolved.
+  recvID: string;
+  contentType: DThreadResourceContentType;
+  page: number;
+  pageSize: number;
+  applicationType: DChatApplicationType;
+  // Added by BE 2026-07-28 — required. `GROUP` for group/bot threads (matches
+  // whichever branch resolved `recvID` to a `groupID`), `SINGLE` for 1-1
+  // threads (`recvID` resolved to the peer's `userID`). NOTE: BE's literal
+  // value here is `SINGLE`, not `USER` — do not confuse with
+  // `DConversationPeer.type`'s unrelated `'USER' | 'GROUP'` union above.
+  chatType: 'SINGLE' | 'GROUP';
+}
+
+/**
+ * Fully verified 2026-07-26 against `POST chat-service/v1/app/messages/resources`
+ * (staging) for all 4 content types (IMAGE/VIDEO/FILE/URL_TEXT) — see
+ * `ResourceCenterService.parseThreadResourceItem` for the exact raw-row → this-shape
+ * mapping. All field names matched the original OpenIM-elem-based assumptions exactly.
+ */
+export interface DThreadResource {
+  id: string; // chatLog.clientMsgID
+  contentType: DThreadResourceContentType;
+  isRevoked: boolean; // BE does NOT pre-filter revoked items, client must (U5, confirmed)
+  sourceUrl?: string; // IMAGE: content.bigPicture.url · VIDEO: content.videoUrl · FILE: content.sourceUrl
+  thumbnailUrl?: string; // IMAGE: content.snapshotPicture.url (640x640 resized) · VIDEO: content.snapshotUrl
+  fileName?: string; // FILE: content.fileName
+  fileSize?: number; // FILE: content.fileSize
+  mimeType?: string; // FILE: content.fileType
+  linkUrl?: string; // URL_TEXT: ex.urlMetadata.url
+  linkTitle?: string; // URL_TEXT: ex.urlMetadata.title
+  linkDomain?: string; // URL_TEXT: NOT provided by BE — derived client-side via extractDomain()
+  linkImageUrl?: string; // URL_TEXT: ex.urlMetadata.image
+  linkDescription?: string; // URL_TEXT: ex.urlMetadata.description (resolves U8)
+  duration?: number; // VIDEO: content.duration (milliseconds)
+  createdAt?: number; // chatLog.sendTime (ms)
+}
+
+/**
+ * `BaseResponse<DThreadResourceListResponse>.data` is a plain array of raw rows
+ * (`{ chatLog, isRevoked, tag, displayTag }`), NOT `{ items: [...] }` — corrected
+ * after fetching a real response (initial assumption was wrong).
+ */
+export type DThreadResourceListResponse = DThreadResourceRawRow[];
+
+export interface DThreadResourceRawRow {
+  chatLog: {
+    clientMsgID: string;
+    serverMsgID: string;
+    contentType: number;
+    content: string; // JSON string — shape depends on contentType, parse per-type
+    ex: string; // JSON string — e.g. `{ applicationType, urlMetadata? }` for URL_TEXT
+    sendTime: number;
+    createTime: number;
+    isRevoked: boolean;
+  };
+  isRevoked: boolean;
+  tag: unknown;
+  displayTag: unknown;
+}

package/src/utils/url.ts

@@ -39,3 +39,14 @@ export function normalizeUrl(url: string) {
   }
   return url;
 }
+
+/**
+ * The resource-center API's `urlMetadata` doesn't include a separate domain field
+ * (confirmed against a real staging response — only `title`/`description`/`image`/
+ * `url`) — derive it from the full URL instead of relying on `new URL()` (avoids a
+ * dependency on a global `URL` polyfill being present on every RN engine target).
+ */
+export function extractDomain(url: string): string {
+  const match = url.match(/^(?:https?:\/\/)?(?:www\.)?([^/?#]+)/i);
+  return match?.[1] ?? url;
+}