@amityco/ts-sdk 7.1.1-67cf0d9.0 → 7.1.1-6dd179b0.0

package/src/channelRepository/events/onChannelLeft.ts

@@ -6,7 +6,6 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareChannelPayload } from '../utils';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
-import { dropFromCache } from '~/cache/api';
 
 type CallbackFn = (
   channel: Amity.StaticInternalChannel,
@@ -41,17 +40,10 @@ export const onChannelLeft = (
         isMessagePreviewUpdated: isLeftByMe,
       });
 
-      const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
-      const isLegacyUnreadCount = client.useLegacyUnreadCount;
-
-      if (isLeftByMe) {
+      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
         preparedPayload.channels.forEach(channel => {
-          if (isConsistentMode) {
-            addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-            deleteChannelUnreadByChannelId(channel.channelId);
-          } else if (isLegacyUnreadCount) {
-            dropFromCache(['channelUnread', 'get', channel.channelId]);
-          }
+          addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+          deleteChannelUnreadByChannelId(channel.channelId);
         });
       }
 

package/src/channelRepository/observers/getChannel.ts

@@ -32,9 +32,8 @@ import { isEqual } from '~/utils/isEqual';
 import { updateChannelCache } from '../utils/updateChannelCache';
 import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
 import { onSubChannelCreated } from '~/subChannelRepository';
-import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
+import { onChannelUnreadUpdatedLocal } from '~/marker/events/onChannelUnreadUpdatedLocal';
 import { constructChannelObject } from '../utils/constructChannelObject';
-import { onChannelUnreadUpdatedLocal } from '../events/onChannelUnreadUpdatedLocal';
 
 /* begin_public_function
   id: channel.get
@@ -296,7 +295,6 @@ export const getChannel = (
         'channel',
       ),
       convertEventPayload(onSubChannelCreated, 'channelId', 'channel'),
-      convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
       convertEventPayload(onChannelUnreadUpdatedLocal, 'channelId', 'channel'),
     ],
     {

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -55,9 +55,8 @@ import { prepareUnreadCountInfo } from '~/channelRepository/utils/prepareUnreadC
 import { resolveUnreadInfoOnChannelEvent } from '~/channelRepository/utils/resolveUnreadInfoOnChannelEvent';
 import { onChannelResolved } from '~/channelRepository/events/onChannelResolved';
 import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFeedMarkerResolved';
-import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
+import { onChannelUnreadUpdatedLocal } from '~/marker/events/onChannelUnreadUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
-import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -567,10 +566,6 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
         },
         action: Amity.ChannelActionType.OnResolveUnread,
       },
-      {
-        fn: convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
-        action: Amity.ChannelActionType.OnUpdate,
-      },
       {
         fn: convertEventPayload(onChannelUnreadUpdatedLocal, 'channelId', 'channel'),
         action: Amity.ChannelActionType.OnUpdate,

package/src/channelRepository/observers/index.ts

@@ -1,3 +1,2 @@
 export * from './getChannel';
 export * from './getChannels';
-export * from './getTotalChannelsUnread';

package/src/channelRepository/utils/constructChannelDynamicValue.ts

@@ -1,27 +1,17 @@
-import { get } from 'http';
 import { shallowClone } from '~/utils/shallowClone';
 import { getChannelIsMentioned } from './getChannelIsMentioned';
 import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
-import { getActiveClient } from '~/client/api/activeClient';
-import { getLegacyChannelUnread } from './getLegacyChannelUnread';
 
 export const constructChannelDynamicValue = (
   channel: Amity.StaticInternalChannel,
 ): Amity.InternalChannel => {
-  const client = getActiveClient();
   const { messageCount, ...rest } = channel;
-
   return shallowClone(rest, {
-    get unreadCount() {
-      return getLegacyChannelUnread(rest.channelId)?.unreadCount ?? 0;
+    get isMentioned() {
+      return getChannelIsMentioned(rest);
     },
     get subChannelsUnreadCount() {
       return getSubChannelsUnreadCount(rest);
     },
-    get isMentioned() {
-      if (client.useLegacyUnreadCount)
-        return getLegacyChannelUnread(rest.channelId)?.isMentioned ?? false;
-      return getChannelIsMentioned(rest);
-    },
   });
 };

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -5,8 +5,9 @@ import { getChannelMarkers } from '~/marker/api/getChannelMarkers';
 import { updateChannelMessagePreviewCache } from '~/messagePreview/utils';
 import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
+import { getChannelIsMentioned } from './getChannelIsMentioned';
 import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
-import { pushToCache } from '~/cache/api';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
@@ -47,48 +48,6 @@ export const preUpdateChannelCache = (
   });
 };
 
-const updateChannelUnread = ({
-  currentUserId,
-  channels,
-  channelUsers,
-}: {
-  currentUserId: Amity.User['userId'];
-  channels: Amity.RawChannel[];
-  channelUsers: Amity.RawMembership<'channel'>[];
-}) => {
-  for (let i = 0; i < channels.length; i += 1) {
-    const cacheKey = ['channelUnread', 'get', channels[i].channelId];
-    const channelUser = channelUsers.find(
-      channelUser =>
-        channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId,
-    );
-
-    let unreadCount = 0;
-    let readToSegment = null;
-    let lastMentionedSegment = null;
-    let isMentioned = false;
-
-    if (channelUser) {
-      readToSegment = channelUser.readToSegment;
-      lastMentionedSegment = channelUser.lastMentionedSegment;
-      unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
-      isMentioned = lastMentionedSegment > readToSegment;
-    }
-
-    const cacheChannelUnread: Amity.ChannelUnread = {
-      channelId: channels[i].channelId,
-      lastSegment: channels[i].messageCount,
-      readToSegment,
-      lastMentionedSegment,
-      unreadCount,
-      isMentioned,
-      isDeleted: channels[i].isDeleted || false,
-    };
-
-    pushToCache(cacheKey, cacheChannelUnread);
-  }
-};
-
 export const prepareChannelPayload = async (
   rawPayload: Amity.ChannelPayload,
   options: { isMessagePreviewUpdated?: boolean } = { isMessagePreviewUpdated: true },
@@ -105,38 +64,28 @@ export const prepareChannelPayload = async (
     updateChannelMessagePreviewCache(rawPayload);
   }
 
-  if (client.useLegacyUnreadCount) {
-    updateChannelUnread({
-      channels: rawPayload.channels,
-      channelUsers: rawPayload.channelUsers,
-      currentUserId: client.userId!,
-    });
-  } else {
-    const markerIds = rawPayload.channels
-      // filter channel by type. Only conversation, community and broadcast type are included.
-      .filter(isUnreadCountSupport)
-      .map(({ channelInternalId }) => channelInternalId);
-
-    if (markerIds.length > 0) {
-      // since the get markers method requires a channel cache to function with the reducer.
-      preUpdateChannelCache(rawPayload, {
-        isMessagePreviewUpdated: options.isMessagePreviewUpdated,
-      });
-
-      try {
-        await getChannelMarkers(markerIds);
-      } catch (e) {
-        // empty block (from the spec, allow marker fetch to fail without having to do anything)
-      }
+  const markerIds = rawPayload.channels
+    // filter channel by type. Only conversation, community and broadcast type are included.
+    .filter(isUnreadCountSupport)
+    .map(({ channelInternalId }) => channelInternalId);
+
+  if (markerIds.length > 0) {
+    // since the get markers method requires a channel cache to function with the reducer.
+    preUpdateChannelCache(rawPayload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated });
+
+    try {
+      await getChannelMarkers(markerIds);
+    } catch (e) {
+      // empty block (from the spec, allow marker fetch to fail without having to do anything)
     }
   }
 
-  // convert raw channel to internal channel
+  // attach marker to channel
   const channels = rawPayload.channels.map(payload =>
     convertFromRaw(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }),
   );
 
-  // convert raw channel user to membership (add user object)
+  // user marker to channel users
   const channelUsers: Amity.Membership<'channel'>[] = rawPayload.channelUsers.map(channelUser => {
     return convertRawMembershipToMembership<'channel'>(channelUser);
   });

package/src/client/api/createClient.ts

@@ -50,7 +50,7 @@ export const createClient = (
     rteEnabled = true,
   }: {
     debugSession?: string;
-    apiEndpoint?: { http?: string; mqtt?: string; upload?: string };
+    apiEndpoint?: { http?: string; mqtt?: string };
     prefixDeviceIdKey?: string;
     rteEnabled?: boolean;
   } = {},
@@ -63,11 +63,9 @@ export const createClient = (
   });
 
   const httpEndpoint = apiEndpoint?.http ?? computeUrl('http', apiRegion);
-  const uploadEndpoint = apiEndpoint?.upload ?? computeUrl('upload', apiRegion);
   const mqttEndpoint = apiEndpoint?.mqtt ?? computeUrl('mqtt', apiRegion);
 
   const http = createHttpTransport(httpEndpoint);
-  const upload = createHttpTransport(uploadEndpoint);
 
   let ws;
   let mqtt;
@@ -88,8 +86,6 @@ export const createClient = (
   const sessionHandler = undefined;
 
   const isUnreadCountEnabled = false;
-  // Legacy unread count is true by default
-  const useLegacyUnreadCount = true;
 
   const client = {
     version: `${VERSION}`,
@@ -107,7 +103,6 @@ export const createClient = (
     http,
     ws,
     mqtt,
-    upload,
     emitter,
 
     /*
@@ -127,7 +122,6 @@ export const createClient = (
     use: () => setActiveClient(client),
 
     isUnreadCountEnabled,
-    useLegacyUnreadCount,
 
     getMarkerSyncConsistentMode,
 

package/src/client/api/enableUnreadCount.ts

@@ -17,7 +17,6 @@ export const enableUnreadCount = () => {
   if (client.isUnreadCountEnabled) return false;
 
   client.isUnreadCountEnabled = true;
-  client.useLegacyUnreadCount = false;
 
   client.emitter.emit('unreadCountEnabled', true);
 

package/src/client/api/login.ts

@@ -11,7 +11,6 @@ import { onUserDeleted } from '~/userRepository/events/onUserDeleted';
 
 import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLoginHandler';
 import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
-import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
 import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
 import { logout } from './logout';
 
@@ -201,13 +200,10 @@ export const login = async (
 
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
+      readReceiptSyncEngineOnLoginHandler(),
       objectResolverEngineOnLoginHandler(),
     );
 
-    if (client.useLegacyUnreadCount) {
-      subscriptions.push(readReceiptSyncEngineOnLoginHandler());
-    } else subscriptions.push(legacyReadReceiptSyncEngineOnLoginHandler());
-
     const markerSyncUnsubscriber = await startMarkerSync();
     subscriptions.push(markerSyncUnsubscriber);
   }

package/src/client/utils/ReadReceiptSync/readReceiptSyncEngine.ts

@@ -1,7 +1,8 @@
 import { pullFromCache, pushToCache, queryCache } from '~/cache/api';
 import { getActiveClient } from '../../api/activeClient';
+import { markAsReadBySegment } from '~/subChannelRepository/api/markAsReadBySegment';
+import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
 import { fireEvent } from '~/core/events';
-import { markChannelsAsReadBySegment } from '~/channelRepository/api/markChannelsAsReadBySegment';
 
 export class MessageReadReceiptSyncEngine {
   private client: Amity.Client;
@@ -37,9 +38,9 @@ export class MessageReadReceiptSyncEngine {
   syncReadReceipts(): void {
     if (this.jobQueue.length === 0 || this.isActive === false) return;
 
-    const readReceipts = this.getReadReceipts();
-    if (readReceipts) {
-      this.markReadApi(readReceipts);
+    const readReceipt = this.getReadReceipt();
+    if (readReceipt) {
+      this.markReadApi(readReceipt);
     }
   }
 
@@ -51,64 +52,79 @@ export class MessageReadReceiptSyncEngine {
 
     // Enqueue unsync read receipts to the job queue
     readReceipts?.forEach(({ data: readReceipt }) => {
-      this.enqueueReadReceipt(readReceipt.channelId, readReceipt.latestSegment);
+      this.enqueueReadReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
     });
   }
 
-  private getReadReceipts(): Amity.ReadReceiptSyncJob[] | undefined {
-    // get all read receipts from queue, now the queue is empty
-    const syncJob = this.jobQueue.splice(0, this.jobQueue.length);
-    if (syncJob.length === 0) return;
+  private getReadReceipt(): Amity.ReadReceiptSyncJob | undefined {
+    // Get first read receipt in queue
+    const syncJob = this.jobQueue[0];
 
-    return syncJob.filter(job => {
-      const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', job.channelId])?.data;
-      if (!readReceipt) return false;
-      if (readReceipt.latestSegment > readReceipt.latestSyncSegment) return true;
-      return false;
-    });
+    if (!syncJob) return;
+    // Skip when it's syncing
+    if (syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) return;
+
+    // Get readReceipt from cache by subChannelId
+    const readReceipt = pullFromCache<Amity.ReadReceipt>([
+      'readReceipt',
+      syncJob.subChannelId,
+    ])?.data;
+
+    if (!readReceipt) return;
+
+    if (readReceipt?.latestSegment > readReceipt?.latestSyncSegment) {
+      syncJob.segment = readReceipt.latestSegment;
+      return syncJob;
+    }
+    // Clear all synced job in job queue
+    this.removeSynedReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
+
+    // Recursion getReadReceipt() until get unsync read receipt or job queue is empty
+    return this.getReadReceipt();
   }
 
-  private async markReadApi(syncJobs: Amity.ReadReceiptSyncJob[]): Promise<void> {
-    // constuct payload
-    // example: [{ channelId: 'channelId', readToSegment: 2 }]
-    const syncJobsPayload = syncJobs.map(job => {
-      return {
-        channelId: job.channelId,
-        readToSegment: job.segment,
-      };
-    });
+  private async markReadApi(syncJob: Amity.ReadReceiptSyncJob): Promise<void> {
+    const newSyncJob = syncJob;
+    newSyncJob.syncState = Amity.ReadReceiptSyncState.SYNCING;
+
+    const { subChannelId, segment } = newSyncJob;
 
-    const response = await markChannelsAsReadBySegment(syncJobsPayload);
+    const response = await markAsReadBySegment({ subChannelId, readToSegment: segment });
 
     if (response) {
-      for (let i = 0; i < syncJobs.length; i += 1) {
-        // update lastestSyncSegment in read receipt cache
-        const cacheKey = ['readReceipt', syncJobs[i].channelId];
-        const readReceiptCache = pullFromCache<Amity.ReadReceipt>(cacheKey)?.data;
-
-        pushToCache(cacheKey, {
-          ...readReceiptCache,
-          latestSyncSegment: syncJobs[i].segment,
-        });
+      this.removeSynedReceipt(syncJob.subChannelId, syncJob.segment);
+
+      const readReceiptCache = pullFromCache<Amity.ReadReceipt>([
+        'readReceipt',
+        subChannelId,
+      ])?.data;
+
+      pushToCache(['readReceipt', subChannelId], {
+        ...readReceiptCache,
+        latestSyncSegment: segment,
+      });
+    } else if (!response) {
+      if (newSyncJob.retryCount > this.MAX_RETRY) {
+        this.removeJobFromQueue(newSyncJob);
+      } else {
+        newSyncJob.retryCount += 1;
+        newSyncJob.syncState = Amity.ReadReceiptSyncState.CREATED;
       }
-    } else {
-      for (let i = 0; i < syncJobs.length; i += 1) {
-        // push them back to queue if the syncing is failed and retry count is less than max retry
-        if (syncJobs[i].retryCount >= this.MAX_RETRY) return;
+    }
+  }
 
-        const updatedJob = {
-          ...syncJobs[i],
-          syncState: Amity.ReadReceiptSyncState.CREATED,
-          retryCount: syncJobs[i].retryCount + 1,
-        };
+  private removeSynedReceipt(subChannelId: string, segment: number) {
+    const syncJobs = this.jobQueue;
 
-        this.enqueueJob(updatedJob);
+    syncJobs.forEach(job => {
+      if (job.subChannelId === subChannelId && job.segment <= segment) {
+        this.removeJobFromQueue(job);
       }
-    }
+    });
   }
 
   private startObservingReadReceiptQueue(): void {
-    if (this.client.useLegacyUnreadCount) {
+    if (this.client.isUnreadCountEnabled) {
       this.isActive = true;
       this.startSyncReadReceipt();
     }
@@ -117,7 +133,8 @@ export class MessageReadReceiptSyncEngine {
   private stopObservingReadReceiptQueue(): void {
     this.isActive = false;
 
-    this.jobQueue.map(job => {
+    const syncJobs = this.jobQueue;
+    syncJobs.map(job => {
       if (job.syncState === Amity.ReadReceiptSyncState.SYNCING) {
         return { ...job, syncState: Amity.ReadReceiptSyncState.CREATED };
       }
@@ -153,51 +170,50 @@ export class MessageReadReceiptSyncEngine {
     this.startObservingReadReceiptQueue();
   }
 
-  markRead(channelId: string, segment: number): void {
-    // Step 1: Optimistic update of channelUnread.readToSegment to message.segment and update unreadCount value
-    const cacheKey = ['channelUnread', 'get', channelId];
-    const channelUnread = pullFromCache<Amity.ChannelUnread>(cacheKey)?.data;
+  markRead(subChannelId: string, segment: number): void {
+    // Step 1: Optimistic update of subChannelUnreadInfo.readToSegment to message.segment
+    const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
+    const subChannelUnreadInfo = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
 
-    if (
-      typeof channelUnread?.readToSegment === 'number' &&
-      channelUnread &&
-      segment > channelUnread.readToSegment
-    ) {
-      channelUnread.readToSegment = segment;
-      channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
+    if (subChannelUnreadInfo && segment > subChannelUnreadInfo.readToSegment) {
+      subChannelUnreadInfo.readToSegment = segment;
+      subChannelUnreadInfo.unreadCount = Math.max(subChannelUnreadInfo.lastSegment - segment, 0);
 
-      pushToCache(cacheKey, channelUnread);
-      fireEvent('local.channelUnread.updated', channelUnread);
+      const channelUnreadInfo = reCalculateChannelUnreadInfo(subChannelUnreadInfo.channelId);
+      fireEvent('local.channelUnread.updated', channelUnreadInfo);
+
+      pushToCache(cacheKey, subChannelUnreadInfo);
+      fireEvent('local.subChannelUnread.updated', subChannelUnreadInfo);
     }
 
     // Step 2: Enqueue the read receipt
-    this.enqueueReadReceipt(channelId, segment);
+    this.enqueueReadReceipt(subChannelId, segment);
   }
 
-  private enqueueReadReceipt(channelId: string, segment: number): void {
-    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', channelId])?.data;
+  private enqueueReadReceipt(subChannelId: string, segment: number): void {
+    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', subChannelId])?.data;
 
-    // Create new read receipt if it's not exists and add the job to queue
+    // Create new read receipt if it's not exists and add job to queue
     if (!readReceipt) {
-      const readReceiptChannel: Amity.ReadReceipt = {
-        channelId,
+      const readReceiptSubChannel: Amity.ReadReceipt = {
+        subChannelId,
         latestSegment: segment,
         latestSyncSegment: 0,
       };
-      pushToCache(['readReceipt', channelId], readReceiptChannel);
+
+      pushToCache(['readReceipt', subChannelId], readReceiptSubChannel);
     } else if (readReceipt.latestSegment < segment) {
-      // Update latestSegment in read receipt cache
-      pushToCache(['readReceipt', channelId], { ...readReceipt, latestSegment: segment });
+      pushToCache(['readReceipt', subChannelId], { ...readReceipt, latestSegment: segment });
     } else if (readReceipt.latestSyncSegment >= segment) {
       // Skip the job when lastSyncSegment > = segment
       return;
     }
 
-    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(channelId);
+    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(subChannelId);
 
     if (syncJob === null || syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) {
       syncJob = {
-        channelId,
+        subChannelId,
         segment,
         syncState: Amity.ReadReceiptSyncState.CREATED,
         retryCount: 0,
@@ -209,9 +225,11 @@ export class MessageReadReceiptSyncEngine {
     }
   }
 
-  private getSyncJob(channelId: string): Amity.ReadReceiptSyncJob | null {
-    const { jobQueue } = this;
-    const targetJob = jobQueue.find(job => job.channelId === channelId);
+  private getSyncJob(subChannelId: string): Amity.ReadReceiptSyncJob | null {
+    const syncJobs = this.jobQueue;
+
+    const targetJob = syncJobs.find(job => job.subChannelId === subChannelId);
+
     return targetJob || null;
   }
 
@@ -224,6 +242,13 @@ export class MessageReadReceiptSyncEngine {
       this.jobQueue.push(syncJob);
     }
   }
+
+  private removeJobFromQueue(item: Amity.ReadReceiptSyncJob) {
+    const index = this.jobQueue.indexOf(item);
+    if (index > -1) {
+      this.jobQueue.splice(index, 1);
+    }
+  }
 }
 
 let instance: MessageReadReceiptSyncEngine | null = null;

package/src/client/utils/endpoints.ts

@@ -6,7 +6,6 @@ export const API_REGIONS = {
 
 const URLS = {
   http: 'https://apix.{region}.amity.co',
-  upload: 'https://upload.{region}.amity.co',
   mqtt: 'wss://sse.{region}.amity.co:443/mqtt',
 } as const;
 

package/src/client/utils/setClientToken.ts

@@ -30,14 +30,6 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
     isUserDeleted: false,
   };
 
-  client.upload.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
-
-  client.upload.defaults.metadata = {
-    tokenExpiry: expiresAt,
-    isGlobalBanned: false,
-    isUserDeleted: false,
-  };
-
   // manually setup the token for ws transport
   if (client.ws) client.ws.io.opts.query = { token: accessToken };
 

package/src/core/model/idResolvers.ts

@@ -26,8 +26,6 @@ const idResolvers: Resolvers = {
   channelUnreadInfo: ({ channelId }) => channelId,
   subChannelUnreadInfo: ({ subChannelId }) => subChannelId,
 
-  channelUnread: ({ channelId }) => channelId,
-
   channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
   subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
   messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,
@@ -61,6 +59,9 @@ const idResolvers: Resolvers = {
 
   pin: ({ placement, referenceId }) => `${placement}#${referenceId}`,
   pinTarget: ({ targetId }) => targetId,
+
+  notificationTrayItem: ({ _id }) => _id,
+  notificationTraySeen: ({ userId }) => userId,
 };
 
 /**

package/src/core/model/index.ts

@@ -52,6 +52,8 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
 
   pinTargets: 'pinTarget',
   pins: 'pin',
+
+  notificationTrayItems: 'notificationTrayItem',
 };
 
 /** hidden */

package/src/fileRepository/api/uploadFile.ts

@@ -42,7 +42,7 @@ export const uploadFile = async <T extends Amity.FileType = any>(
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.upload.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
     headers,
     onUploadProgress({ loaded, total = 100 }) {
       onProgress && onProgress(Math.round((loaded * 100) / total));

package/src/fileRepository/api/uploadImage.ts

@@ -42,7 +42,7 @@ export const uploadImage = async (
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.upload.post<Amity.CreateFilePayload<'image'>>(
+  const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
     '/api/v4/images',
     formData,
     {

package/src/fileRepository/api/uploadVideo.ts

@@ -48,7 +48,7 @@ export const uploadVideo = async (
       ? (formData as any).getHeaders()
       : { 'content-type': 'multipart/form-data' };
 
-  const { data } = await client.upload.post<Amity.CreateFilePayload<'video'>>(
+  const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
     '/api/v4/videos',
     formData,
     {

package/src/index.ts

@@ -49,3 +49,5 @@ export * as AdRepository from './adRepository';
 
 // // external apis
 export * from './external/api';
+
+export * as notificationTray from './notificationTray';