@amityco/ts-sdk 6.17.3 → 6.18.0

package/src/marker/api/getChannelMarkers.ts

@@ -2,7 +2,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertChannelMarkerResponse, convertUserMarkerResponse } from '~/utils/marker';
+import { convertChannelMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -31,10 +31,8 @@ export const getChannelMarkers = async (
     },
   });
 
-  const { userEntityMarkers: userEntityMarkersPayload, userMarkers: userMarkersPayload } =
-    queryPayload;
+  const { userEntityMarkers: userEntityMarkersPayload, userMarkers } = queryPayload;
 
-  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
   const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
 
   const cachedAt = client.cache && Date.now();

package/src/marker/api/getMessageMarkers.ts

@@ -1,8 +1,6 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
-import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertUserMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -34,9 +32,7 @@ export const getMessageMarkers = async (
     },
   );
 
-  const { contentMarkers, feedMarkers, userMarkers: userMarkersPayload } = queryPayload;
-
-  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+  const { contentMarkers, feedMarkers, userMarkers } = queryPayload;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });

package/src/marker/api/getSubChannelMarkers.ts

@@ -2,11 +2,8 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import {
-  convertChannelMarkerResponse,
-  convertSubChannelMarkerResponse,
-  convertUserMarkerResponse,
-} from '~/utils/marker';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
+import { persistUnreadCountInfo } from '../utils/persistUnreadCountInfo';
 
 /**
  * ```js
@@ -46,10 +43,18 @@ export const getSubChannelMarkers = async (
   const {
     userEntityMarkers: userEntityMarkersPayload,
     userFeedMarkers: userFeedMarkersPayload,
-    userMarkers: userMarkersPayload,
+    userMarkers,
+    feedMarkers: feedMarkersPayload,
   } = payload;
 
-  const userMarkers = convertUserMarkerResponse(userMarkersPayload);
+  // if consistent mode is enabled, persist the unread count info to the cache
+  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+    persistUnreadCountInfo({
+      feedMarkers: feedMarkersPayload,
+      userFeedMarkers: userFeedMarkersPayload,
+    });
+  }
+
   const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
   const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
 

package/src/marker/api/getUserMarker.ts

@@ -1,10 +1,8 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api/activeClient';
 import { fireEvent } from '~/core/events';
-// import { convertMarkerResponse } from '~/utils/marker';
-import { convertUserMarkerResponse } from '~/utils/marker';
 
-export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker | null>> => {
+export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker | undefined>> => {
   const client = getActiveClient();
   client.log('channel/getUserMarker');
 
@@ -12,12 +10,7 @@ export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker | n
     `/api/v1/markers/userMarker`,
   );
 
-  const { userMarkers: UserMarkersPayload } = payload;
-
-  /*
-    change field isMentioned from backend to be hasMentioned
-  */
-  const userMarkers = convertUserMarkerResponse(UserMarkersPayload);
+  const { userMarkers } = payload;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache({ userMarkers }, { cachedAt });
@@ -33,7 +26,7 @@ export const getUserMarker = async (): Promise<Amity.Cached<Amity.UserMarker | n
     }
 
     return maxUserMarker;
-  }, null as Amity.UserMarker | null);
+  }, undefined as Amity.UserMarker | undefined);
 
   return { data: latestUserMarker, cachedAt };
 };

package/src/marker/api/getUserMessageFeedMarkers.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const getUserMessageFeedMakers = async (
+  channelIds: Amity.RawChannel['channelId'][],
+): Promise<Amity.UserMessageFeedMarkerPayload> => {
+  const client = getActiveClient();
+  client.log('channel/getUserMessageFeedMakers', channelIds);
+
+  const { data } = await client.http.get<Amity.UserMessageFeedMarkerPayload>(
+    `/api/v1/markers/user-message-feed`,
+    {
+      params: {
+        channelIds,
+      },
+    },
+  );
+
+  return data;
+};

package/src/marker/api/tests/getSubChannelMarkers.test.ts

@@ -6,6 +6,7 @@ import {
   client,
   generateChannelMarker,
   generateChannelMarkerResponse,
+  generateFeedMarkerResponse,
   generateSubChannelMarker,
   generateSubChannelMarkerResponse,
   generateUserMarker,
@@ -29,6 +30,11 @@ const channelMarkersResponse = [
 ];
 const userMarkersResponse = [generateUserMarkerResponse({ userId: 'currentUser1' })];
 
+const feedMarkerResponse = [
+  generateFeedMarkerResponse({ feedId: 'sub-ch1', entityId: 'ch1' }),
+  generateFeedMarkerResponse({ feedId: 'sub-ch2', entityId: 'ch1' }),
+];
+
 const expectedSubChannelMarkers = [
   generateSubChannelMarker({ feedId: 'sub-ch1', entityId: 'ch1' }),
   generateSubChannelMarker({ feedId: 'sub-ch2', entityId: 'ch1' }),
@@ -41,6 +47,7 @@ const subChannelMarkerCacheIds = expectedSubChannelMarkers.map(subChannelMarkerR
 
 const resolvedGetValue = {
   data: {
+    feedMarkers: feedMarkerResponse,
     userFeedMarkers: subChannelMarkerResponse,
     userEntityMarkers: channelMarkersResponse,
     userMarkers: userMarkersResponse,

package/src/marker/events/onChannelMarkerFetched.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onChannelMarkerUpdated.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onFeedlMarkerFetched.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onFeedlMarkerUpdated.ts

@@ -1,5 +1,5 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onMessageMarked.ts

@@ -1,7 +1,7 @@
 import { get } from 'http';
 import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { isObject } from '~/utils/object';
@@ -44,24 +44,40 @@ export const onMessageMarked = (
 
       if (currentMessageCollection.length > 0 && contentMarkers?.length > 0) {
         const currentMessages =
-          currentMessageCollection[0].data?.data?.map(messageId => {
-            return pullFromCache<Amity.Message>(['message', 'get', messageId]);
-          }) || [];
+          currentMessageCollection[0].data?.data
+            ?.map(messageId => pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])!)
+            .map(({ data }) => data)
+            .filter(Boolean) ?? [];
 
         currentMessages.forEach(message => {
-          const isSameSubChannelId = contentMarkers[0].feedId === message?.data.subChannelId;
-          const isReadCountLatest = contentMarkers[0].readCount > message?.data.readCount!;
+          const cacheKeyMessageMarker = [
+            'messageMarker',
+            'get',
+            getResolver('messageMarker')({
+              creatorId: message.creatorPrivateId,
+              feedId: message.subChannelId,
+              contentId: message.messageId,
+            }),
+          ];
+
+          const messageMarker = pullFromCache<Amity.MessageMarker>(cacheKeyMessageMarker)?.data;
+
+          if (!messageMarker) return;
+
+          const isSameSubChannelId = contentMarkers[0].feedId === messageMarker.feedId;
+          const isReadCountLatest = contentMarkers[0].readCount > messageMarker.readCount!;
           const isDeliveredCountLatest =
-            contentMarkers[0]?.deliveredCount > message?.data.deliveredCount!;
+            contentMarkers[0]?.deliveredCount > messageMarker.deliveredCount!;
 
           if (isSameSubChannelId) {
-            pushToCache(['message', 'get', message.data.messageId], {
-              ...message.data,
-              readCount: isReadCountLatest ? contentMarkers[0].readCount : message?.data.readCount!,
+            const newCacheData = {
+              ...messageMarker,
+              readCount: isReadCountLatest ? contentMarkers[0].readCount : messageMarker.readCount!,
               deliveredCount: isDeliveredCountLatest
                 ? contentMarkers[0].deliveredCount
-                : message?.data.deliveredCount!,
-            });
+                : messageMarker.deliveredCount!,
+            };
+            pushToCache(cacheKeyMessageMarker, newCacheData);
           }
         });
       }

package/src/marker/events/onMessageMarkerFetched.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onSubChannelMarkerFetched.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onSubChannelMarkerUpdated.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onUserFeedMarkerUpdated.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+import { persistUnreadCountInfo } from '../utils/persistUnreadCountInfo';
+
+/**
+ * ```js
+ * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerUpdated(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserFeedMarker} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+export const onUserFeedMarkerUpdated = (
+  callback: Amity.Listener<Amity.FeedMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['marker.userFeed-updated']) => {
+    // update sub channel unread info and channel unread info in cache
+    persistUnreadCountInfo(payload);
+
+    callback(payload.feedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'feedMarker/onUserFeedMarkerUpdated',
+    'marker.userFeed-updated',
+    filter,
+  );
+};

package/src/marker/events/onUserMarkerFetched.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 
 /**

package/src/marker/events/onUserMarkerSync.ts

@@ -1,11 +1,7 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
-import {
-  convertChannelMarkerResponse,
-  convertSubChannelMarkerResponse,
-  convertUserMarkerResponse,
-} from '~/utils/marker';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
 
 /**
  * ```js
@@ -29,13 +25,12 @@ export const onUserMarkerSync = (
 
   const filter = (payload: Amity.Events['marker.user-sync']) => {
     const {
-      userMarkers: userMarkersPayload,
+      userMarkers,
       userEntityMarkers: userEntityMarkersPayload,
       userFeedMarkers: userFeedMarkersPayload,
       ...rest
     } = payload;
 
-    const userMarkers = convertUserMarkerResponse(userMarkersPayload);
     const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
     const userFeedMarker = convertSubChannelMarkerResponse(userFeedMarkersPayload);
 

package/src/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId.ts

@@ -0,0 +1,19 @@
+import { pushToCache, queryCache } from '~/cache/api';
+
+export const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId: string) => {
+  const cacheKey = ['subChannelUnreadInfo', 'get'];
+  const cachedSubChannelUnread = queryCache<Amity.SubChannelUnreadInfo>(cacheKey);
+
+  if (cachedSubChannelUnread) {
+    const cachedTargetSubChannelUnread = cachedSubChannelUnread?.filter(
+      ({ data }) => data.channelId === channelId,
+    );
+
+    cachedTargetSubChannelUnread.forEach(({ key, data }) => {
+      pushToCache(key, {
+        ...data,
+        isDeleted: true,
+      });
+    });
+  }
+};

package/src/marker/utils/addFlagIsDeletedSubChannelUnreadBySubChannelId.ts

@@ -0,0 +1,13 @@
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+export const addFlagIsDeletedSubChannelUnreadBySubChannelId = (subChannelId: string) => {
+  const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
+  const cachedSubChannelUnread = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
+
+  if (cachedSubChannelUnread) {
+    pushToCache(cacheKey, {
+      ...cachedSubChannelUnread,
+      isDeleted: true,
+    });
+  }
+};

package/src/marker/utils/deleteChannelUnreadByChannelId.ts

@@ -0,0 +1,11 @@
+import { pullFromCache, dropFromCache } from '~/cache/api';
+
+export const deleteChannelUnreadByChannelId = (channelId: string) => {
+  const channelUnreadInfoCacheKey = ['channelUnreadInfo', 'get', channelId];
+  const channelUnreadInfoCache =
+    pullFromCache<Amity.ChannelUnreadInfo>(channelUnreadInfoCacheKey)?.data;
+
+  if (channelUnreadInfoCache) {
+    dropFromCache(channelUnreadInfoCacheKey);
+  }
+};

package/src/marker/utils/persistUnreadCountInfo.ts

@@ -0,0 +1,47 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { reCalculateChannelUnreadInfo } from './reCalculateChannelUnreadInfo';
+
+export const persistUnreadCountInfo = (payload: Amity.UserFeedUpdatedPayload) => {
+  const { feedMarkers, userFeedMarkers } = payload;
+
+  // calculate sub channel unread info and channel unread info
+  if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
+    const channelIds: string[] = [];
+
+    const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
+
+    userFeedMarkers.forEach(userFeedMarker => {
+      const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
+      if (!feedMarker) return;
+
+      if (feedMarker.feedId === userFeedMarker.feedId) {
+        const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
+
+        const subChannelUnreadInfo: Amity.SubChannelUnreadInfo = {
+          subChannelId: feedMarker.feedId,
+          channelId: feedMarker.entityId,
+          readToSegment: userFeedMarker.readToSegment,
+          lastSegment: feedMarker.lastSegment,
+          lastMentionSegment: userFeedMarker.lastMentionSegment,
+          unreadCount: Math.max(0, unreadCount),
+          isMentioned: userFeedMarker.isMentioned,
+          isDeleted: feedMarker.isDeleted,
+          createdAt: userFeedMarker.createdAt,
+          updatedAt: userFeedMarker.updatedAt,
+        };
+
+        // update sub channel unread info in cache
+        ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
+
+        if (!channelIds.includes(feedMarker.entityId)) {
+          channelIds.push(feedMarker.entityId);
+        }
+      }
+    });
+
+    // re-calculate channel unread info in cache
+    channelIds.forEach(channelId => {
+      reCalculateChannelUnreadInfo(channelId);
+    });
+  }
+};

package/src/marker/utils/reCalculateChannelUnreadInfo.ts

@@ -0,0 +1,37 @@
+import { pushToCache, queryCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+
+export const reCalculateChannelUnreadInfo = async (channelId: string) => {
+  const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
+  const cacheChannelUnreadInfo =
+    pullFromCache<Amity.ChannelUnreadInfo>(cacheKeyChannelUnread)?.data;
+
+  const cacheKeySubChannelUnread = ['subChannelUnreadInfo', 'get'];
+  const cachedSubChannelUnreadInfo =
+    queryCache<Amity.SubChannelUnreadInfo>(cacheKeySubChannelUnread);
+
+  let channelUnreads = 0;
+  let isMentioned = false;
+
+  if (cachedSubChannelUnreadInfo && cachedSubChannelUnreadInfo?.length > 0) {
+    const subChannelUnreadsInfo = cachedSubChannelUnreadInfo?.filter(({ data }) => {
+      return data.channelId === channelId && !data.isDeleted;
+    });
+
+    channelUnreads = subChannelUnreadsInfo
+      .map(({ data }) => data.unreadCount)
+      .reduce((acc, cur) => acc + cur, 0);
+
+    isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
+  }
+
+  pushToCache(cacheKeyChannelUnread, {
+    ...(cacheChannelUnreadInfo ?? {
+      channelId,
+      createdAt: new Date().toISOString(),
+    }),
+    updatedAt: new Date().toISOString(),
+    unreadCount: channelUnreads,
+    isMentioned,
+  });
+};

package/src/marker/utils/updateSubChannelUnreadFromMessage.ts

@@ -0,0 +1,40 @@
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+
+export const updateSubChannelUnreadFromMessage = (message: Amity.RawMessage) => {
+  const client = getActiveClient();
+  const cacheKeyUnreadCount = ['subChannelUnreadInfo', 'get', message.messageFeedId];
+  const cachedUnreadCount = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKeyUnreadCount)?.data;
+
+  if (!cachedUnreadCount) return;
+
+  const lastSegment =
+    cachedUnreadCount.lastSegment < message.segment
+      ? message.segment
+      : cachedUnreadCount.lastSegment;
+
+  const unreadCount = lastSegment - cachedUnreadCount.readToSegment;
+
+  let { lastMentionSegment } = cachedUnreadCount;
+
+  if (message.mentionedUsers && message.mentionedUsers.length > 0) {
+    message.mentionedUsers.forEach(mention => {
+      if (
+        mention.type === 'channel' ||
+        (mention.type === 'user' && client.userId && mention.userPublicIds.includes(client.userId))
+      ) {
+        lastMentionSegment = message.segment;
+      }
+    });
+  }
+
+  const updatedCachedUnreadCount = {
+    ...cachedUnreadCount,
+    lastMentionSegment,
+    lastSegment,
+    isMentioned: !(cachedUnreadCount.readToSegment >= lastMentionSegment),
+    unreadCount: Math.max(unreadCount, 0),
+  };
+
+  pushToCache(cacheKeyUnreadCount, updatedCachedUnreadCount);
+};

package/src/messagePreview/utils/updateMessagePreviewFromMessage.ts

@@ -1,7 +1,7 @@
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { updateSubChannelCache } from '../../subChannelRepository/utils/updateSubChannelCache';
 
-export const handleMessageCreated = async (message: Amity.Message) => {
+export const handleMessageCreated = async (message: Amity.InternalMessage) => {
   const {
     channelId,
     messageId: messagePreviewId,
@@ -94,7 +94,7 @@ export const handleMessageCreated = async (message: Amity.Message) => {
   }
 };
 
-export const handleMessageUpdated = async (message: Amity.Message) => {
+export const handleMessageUpdated = async (message: Amity.InternalMessage) => {
   const {
     channelId,
     messageId: messagePreviewId,

package/src/messageRepository/api/createMessage.ts

@@ -1,11 +1,12 @@
 import { uuid } from '~/core/uuid';
 import { fireEvent } from '~/core/events';
-import { getActiveClient } from '~/client/api';
+import { getActiveClient, getActiveUser } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
 
 import { convertParams, prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 const getLocalId = () => `LOCAL_${uuid()}`;
 
@@ -80,7 +81,7 @@ export const createMessage = async <T extends Amity.MessageContentType>(
   fireEvent('local.message.created', { messages });
 
   return {
-    data: messages[0],
+    data: LinkedObject.message(messages[0]),
     cachedAt,
   };
 };
@@ -147,12 +148,13 @@ createMessage.optimistically = ({
 
   const message = {
     creatorId: client.userId!,
+    creatorPrivateId: getActiveUser()._id,
     channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
     childrenNumber: 0,
     createdAt: createdTime,
     updatedAt: createdTime,
     ...bundleWithMessageId,
-  } as Amity.Message;
+  } as Amity.InternalMessage;
 
   const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
 
@@ -161,7 +163,7 @@ createMessage.optimistically = ({
 
   return {
     cachedAt,
-    data: message,
+    data: LinkedObject.message(message),
   };
 };
 /* end_public_function */

package/src/messageRepository/api/deleteMessage.ts

@@ -1,7 +1,8 @@
 import { getActiveClient } from '~/client/api';
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
-import { getMessage } from './getMessage';
+import { getMessage } from '../internalApi/getMessage';
+import { LinkedObject } from '~/utils/linkedObject';
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
@@ -28,7 +29,7 @@ export const deleteMessage = async (
   );
   const deleted = await getMessage(messageId);
   fireEvent('local.message.deleted', { messages: [deleted.data] });
-  return deleted.data;
+  return LinkedObject.message(deleted.data);
 };
 
 /**
@@ -50,11 +51,11 @@ deleteMessage.optimistically = (
   const client = getActiveClient();
   client.log('message/deleteMessage.optimistically', messageId);
 
-  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+  const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId]);
 
   if (!message) return;
   const cachedAt = -1;
-  const deleted: Amity.Message = {
+  const deleted: Amity.InternalMessage = {
     ...message.data,
     isDeleted: true,
     updatedAt: new Date().toISOString(),
@@ -62,7 +63,7 @@ deleteMessage.optimistically = (
   upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
   fireEvent('local.message.deleted', { messages: [deleted] });
   return {
-    data: deleted,
+    data: LinkedObject.message(deleted),
     cachedAt,
   };
 };