@amityco/ts-sdk-react-native 7.0.3-d7a9877.0 → 7.1.1-0e753e3.0

package/src/client/api/createClient.ts

@@ -51,7 +51,7 @@ export const createClient = (
     rteEnabled = true,
   }: {
     debugSession?: string;
-    apiEndpoint?: { http?: string; mqtt?: string };
+    apiEndpoint?: { http?: string; mqtt?: string; upload?: string };
     prefixDeviceIdKey?: string;
     rteEnabled?: boolean;
   } = {},
@@ -64,9 +64,11 @@ 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;
@@ -87,6 +89,8 @@ export const createClient = (
   const sessionHandler = undefined;
 
   const isUnreadCountEnabled = false;
+  // Legacy unread count is true by default
+  const useLegacyUnreadCount = true;
 
   const client = {
     version: `${VERSION}`,
@@ -104,6 +108,7 @@ export const createClient = (
     http,
     ws,
     mqtt,
+    upload,
     emitter,
 
     /*
@@ -125,6 +130,7 @@ export const createClient = (
     use: () => setActiveClient(client),
 
     isUnreadCountEnabled,
+    useLegacyUnreadCount,
 
     getMarkerSyncConsistentMode,
 

package/src/client/api/enableUnreadCount.ts

@@ -17,6 +17,7 @@ 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,6 +11,7 @@ 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';
 
@@ -200,10 +201,13 @@ 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/legacyReadReceiptSyncEngine.ts

@@ -0,0 +1,267 @@
+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';
+
+export class LegacyMessageReadReceiptSyncEngine {
+  private client: Amity.Client;
+
+  private isActive = true;
+
+  private MAX_RETRY = 3;
+
+  private JOB_QUEUE_SIZE = 120;
+
+  private jobQueue: Amity.LegacyReadReceiptSyncJob[] = [];
+
+  private timer: NodeJS.Timer | undefined;
+
+  // Interval for message read receipt sync in seconds
+  private RECEIPT_SYNC_INTERVAL = 1;
+
+  constructor() {
+    this.client = getActiveClient();
+    // Get remaining unsync read receipts from cache
+    this.getUnsyncJobs();
+  }
+
+  //  Call this when client call client.login
+  startSyncReadReceipt() {
+    // Start timer when start receipt sync
+    this.timer = setInterval(() => {
+      this.syncReadReceipts();
+    }, this.RECEIPT_SYNC_INTERVAL * 1000);
+  }
+
+  // Read receipt observer handling
+  syncReadReceipts(): void {
+    if (this.jobQueue.length === 0 || this.isActive === false) return;
+
+    const readReceipt = this.getReadReceipt();
+    if (readReceipt) {
+      this.markReadApi(readReceipt);
+    }
+  }
+
+  private getUnsyncJobs(): void {
+    // Get all read receipts that has latestSyncSegment < latestSegment
+    const readReceipts = queryCache<Amity.LegacyReadReceipt>(['legacyReadReceipt'])?.filter(
+      ({ data }) => {
+        return data.latestSyncSegment < data.latestSegment;
+      },
+    );
+
+    // Enqueue unsync read receipts to the job queue
+    readReceipts?.forEach(({ data: readReceipt }) => {
+      this.enqueueReadReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
+    });
+  }
+
+  private getReadReceipt(): Amity.LegacyReadReceiptSyncJob | undefined {
+    // Get first read receipt in queue
+    const syncJob = this.jobQueue[0];
+
+    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.LegacyReadReceipt>([
+      'legacyReadReceipt',
+      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(syncJob: Amity.LegacyReadReceiptSyncJob): Promise<void> {
+    const newSyncJob = syncJob;
+    newSyncJob.syncState = Amity.ReadReceiptSyncState.SYNCING;
+
+    const { subChannelId, segment } = newSyncJob;
+
+    const response = await markAsReadBySegment({ subChannelId, readToSegment: segment });
+
+    if (response) {
+      this.removeSynedReceipt(syncJob.subChannelId, syncJob.segment);
+
+      const readReceiptCache = pullFromCache<Amity.LegacyReadReceipt>([
+        'legacyReadReceipt',
+        subChannelId,
+      ])?.data;
+
+      pushToCache(['legacyReadReceipt', 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;
+      }
+    }
+  }
+
+  private removeSynedReceipt(subChannelId: string, segment: number) {
+    const syncJobs = this.jobQueue;
+
+    syncJobs.forEach(job => {
+      if (job.subChannelId === subChannelId && job.segment <= segment) {
+        this.removeJobFromQueue(job);
+      }
+    });
+  }
+
+  private startObservingReadReceiptQueue(): void {
+    if (this.client.isUnreadCountEnabled) {
+      this.isActive = true;
+      this.startSyncReadReceipt();
+    }
+  }
+
+  private stopObservingReadReceiptQueue(): void {
+    this.isActive = false;
+
+    const syncJobs = this.jobQueue;
+    syncJobs.map(job => {
+      if (job.syncState === Amity.ReadReceiptSyncState.SYNCING) {
+        return { ...job, syncState: Amity.ReadReceiptSyncState.CREATED };
+      }
+
+      return job;
+    });
+
+    if (this.timer) clearInterval(this.timer);
+  }
+
+  // Session Management
+  onSessionEstablished(): void {
+    this.startObservingReadReceiptQueue();
+  }
+
+  onSessionDestroyed(): void {
+    this.stopObservingReadReceiptQueue();
+    this.jobQueue = [];
+  }
+
+  onTokenExpired(): void {
+    this.stopObservingReadReceiptQueue();
+  }
+
+  // Network Connection Management
+  onNetworkOffline(): void {
+    // Stop observing to the read receipt queue.
+    this.stopObservingReadReceiptQueue();
+  }
+
+  onNetworkOnline(): void {
+    // Resume observing to the read receipt queue.
+    this.startObservingReadReceiptQueue();
+  }
+
+  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 (subChannelUnreadInfo && segment > subChannelUnreadInfo.readToSegment) {
+      subChannelUnreadInfo.readToSegment = segment;
+      subChannelUnreadInfo.unreadCount = Math.max(subChannelUnreadInfo.lastSegment - segment, 0);
+
+      const channelUnreadInfo = reCalculateChannelUnreadInfo(subChannelUnreadInfo.channelId);
+      fireEvent('local.channelUnreadInfo.updated', channelUnreadInfo);
+
+      pushToCache(cacheKey, subChannelUnreadInfo);
+      fireEvent('local.subChannelUnread.updated', subChannelUnreadInfo);
+    }
+
+    // Step 2: Enqueue the read receipt
+    this.enqueueReadReceipt(subChannelId, segment);
+  }
+
+  private enqueueReadReceipt(subChannelId: string, segment: number): void {
+    const readReceipt = pullFromCache<Amity.LegacyReadReceipt>([
+      'legacyReadReceipt',
+      subChannelId,
+    ])?.data;
+
+    // Create new read receipt if it's not exists and add job to queue
+    if (!readReceipt) {
+      const readReceiptSubChannel: Amity.LegacyReadReceipt = {
+        subChannelId,
+        latestSegment: segment,
+        latestSyncSegment: 0,
+      };
+
+      pushToCache(['legacyReadReceipt', subChannelId], readReceiptSubChannel);
+    } else if (readReceipt.latestSegment < segment) {
+      pushToCache(['legacyReadReceipt', subChannelId], { ...readReceipt, latestSegment: segment });
+    } else if (readReceipt.latestSyncSegment >= segment) {
+      // Skip the job when lastSyncSegment > = segment
+      return;
+    }
+
+    let syncJob: Amity.LegacyReadReceiptSyncJob | null = this.getSyncJob(subChannelId);
+
+    if (syncJob === null || syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) {
+      syncJob = {
+        subChannelId,
+        segment,
+        syncState: Amity.ReadReceiptSyncState.CREATED,
+        retryCount: 0,
+      };
+
+      this.enqueueJob(syncJob);
+    } else if (syncJob.segment < segment) {
+      syncJob.segment = segment;
+    }
+  }
+
+  private getSyncJob(subChannelId: string): Amity.LegacyReadReceiptSyncJob | null {
+    const syncJobs = this.jobQueue;
+
+    const targetJob = syncJobs.find(job => job.subChannelId === subChannelId);
+
+    return targetJob || null;
+  }
+
+  private enqueueJob(syncJob: Amity.LegacyReadReceiptSyncJob) {
+    if (this.jobQueue.length < this.JOB_QUEUE_SIZE) {
+      this.jobQueue.push(syncJob);
+    } else {
+      // Remove oldest job when queue reach maximum capacity
+      this.jobQueue.shift();
+      this.jobQueue.push(syncJob);
+    }
+  }
+
+  private removeJobFromQueue(item: Amity.LegacyReadReceiptSyncJob) {
+    const index = this.jobQueue.indexOf(item);
+    if (index > -1) {
+      this.jobQueue.splice(index, 1);
+    }
+  }
+}
+
+let instance: LegacyMessageReadReceiptSyncEngine | null = null;
+
+export default {
+  getInstance: () => {
+    if (!instance) instance = new LegacyMessageReadReceiptSyncEngine();
+
+    return instance;
+  },
+};

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

@@ -0,0 +1,21 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import LegacyReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine';
+
+export default () => {
+  const readReceiptSyncEngine = LegacyReadReceiptSyncEngine.getInstance();
+  readReceiptSyncEngine.startSyncReadReceipt();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      readReceiptSyncEngine.onSessionEstablished();
+    } else if (state === Amity.SessionStates.TOKEN_EXPIRED) {
+      readReceiptSyncEngine.onTokenExpired();
+    } else {
+      readReceiptSyncEngine.onSessionDestroyed();
+    }
+  });
+
+  return () => {
+    readReceiptSyncEngine.onSessionDestroyed();
+  };
+};

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

@@ -1,8 +1,7 @@
 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;
@@ -38,9 +37,9 @@ export class MessageReadReceiptSyncEngine {
   syncReadReceipts(): void {
     if (this.jobQueue.length === 0 || this.isActive === false) return;
 
-    const readReceipt = this.getReadReceipt();
-    if (readReceipt) {
-      this.markReadApi(readReceipt);
+    const readReceipts = this.getReadReceipts();
+    if (readReceipts) {
+      this.markReadApi(readReceipts);
     }
   }
 
@@ -52,79 +51,64 @@ export class MessageReadReceiptSyncEngine {
 
     // Enqueue unsync read receipts to the job queue
     readReceipts?.forEach(({ data: readReceipt }) => {
-      this.enqueueReadReceipt(readReceipt.subChannelId, readReceipt.latestSegment);
+      this.enqueueReadReceipt(readReceipt.channelId, readReceipt.latestSegment);
     });
   }
 
-  private getReadReceipt(): Amity.ReadReceiptSyncJob | undefined {
-    // Get first read receipt in queue
-    const syncJob = this.jobQueue[0];
+  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;
 
-    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();
+    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;
+    });
   }
 
-  private async markReadApi(syncJob: Amity.ReadReceiptSyncJob): Promise<void> {
-    const newSyncJob = syncJob;
-    newSyncJob.syncState = Amity.ReadReceiptSyncState.SYNCING;
-
-    const { subChannelId, segment } = newSyncJob;
+  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,
+      };
+    });
 
-    const response = await markAsReadBySegment({ subChannelId, readToSegment: segment });
+    const response = await markChannelsAsReadBySegment(syncJobsPayload);
 
     if (response) {
-      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;
+      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,
+        });
       }
-    }
-  }
+    } 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;
 
-  private removeSynedReceipt(subChannelId: string, segment: number) {
-    const syncJobs = this.jobQueue;
+        const updatedJob = {
+          ...syncJobs[i],
+          syncState: Amity.ReadReceiptSyncState.CREATED,
+          retryCount: syncJobs[i].retryCount + 1,
+        };
 
-    syncJobs.forEach(job => {
-      if (job.subChannelId === subChannelId && job.segment <= segment) {
-        this.removeJobFromQueue(job);
+        this.enqueueJob(updatedJob);
       }
-    });
+    }
   }
 
   private startObservingReadReceiptQueue(): void {
-    if (this.client.isUnreadCountEnabled) {
+    if (this.client.useLegacyUnreadCount) {
       this.isActive = true;
       this.startSyncReadReceipt();
     }
@@ -133,8 +117,7 @@ export class MessageReadReceiptSyncEngine {
   private stopObservingReadReceiptQueue(): void {
     this.isActive = false;
 
-    const syncJobs = this.jobQueue;
-    syncJobs.map(job => {
+    this.jobQueue.map(job => {
       if (job.syncState === Amity.ReadReceiptSyncState.SYNCING) {
         return { ...job, syncState: Amity.ReadReceiptSyncState.CREATED };
       }
@@ -170,50 +153,51 @@ export class MessageReadReceiptSyncEngine {
     this.startObservingReadReceiptQueue();
   }
 
-  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;
+  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;
 
-    if (subChannelUnreadInfo && segment > subChannelUnreadInfo.readToSegment) {
-      subChannelUnreadInfo.readToSegment = segment;
-      subChannelUnreadInfo.unreadCount = Math.max(subChannelUnreadInfo.lastSegment - segment, 0);
+    if (
+      typeof channelUnread?.readToSegment === 'number' &&
+      channelUnread &&
+      segment > channelUnread.readToSegment
+    ) {
+      channelUnread.readToSegment = segment;
+      channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
 
-      const channelUnreadInfo = reCalculateChannelUnreadInfo(subChannelUnreadInfo.channelId);
-      fireEvent('local.channelUnread.updated', channelUnreadInfo);
-
-      pushToCache(cacheKey, subChannelUnreadInfo);
-      fireEvent('local.subChannelUnread.updated', subChannelUnreadInfo);
+      pushToCache(cacheKey, channelUnread);
+      fireEvent('local.channelUnread.updated', channelUnread);
     }
 
     // Step 2: Enqueue the read receipt
-    this.enqueueReadReceipt(subChannelId, segment);
+    this.enqueueReadReceipt(channelId, segment);
   }
 
-  private enqueueReadReceipt(subChannelId: string, segment: number): void {
-    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', subChannelId])?.data;
+  private enqueueReadReceipt(channelId: string, segment: number): void {
+    const readReceipt = pullFromCache<Amity.ReadReceipt>(['readReceipt', channelId])?.data;
 
-    // Create new read receipt if it's not exists and add job to queue
+    // Create new read receipt if it's not exists and add the job to queue
     if (!readReceipt) {
-      const readReceiptSubChannel: Amity.ReadReceipt = {
-        subChannelId,
+      const readReceiptChannel: Amity.ReadReceipt = {
+        channelId,
         latestSegment: segment,
         latestSyncSegment: 0,
       };
-
-      pushToCache(['readReceipt', subChannelId], readReceiptSubChannel);
+      pushToCache(['readReceipt', channelId], readReceiptChannel);
     } else if (readReceipt.latestSegment < segment) {
-      pushToCache(['readReceipt', subChannelId], { ...readReceipt, latestSegment: segment });
+      // Update latestSegment in read receipt cache
+      pushToCache(['readReceipt', channelId], { ...readReceipt, latestSegment: segment });
     } else if (readReceipt.latestSyncSegment >= segment) {
       // Skip the job when lastSyncSegment > = segment
       return;
     }
 
-    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(subChannelId);
+    let syncJob: Amity.ReadReceiptSyncJob | null = this.getSyncJob(channelId);
 
     if (syncJob === null || syncJob.syncState === Amity.ReadReceiptSyncState.SYNCING) {
       syncJob = {
-        subChannelId,
+        channelId,
         segment,
         syncState: Amity.ReadReceiptSyncState.CREATED,
         retryCount: 0,
@@ -225,11 +209,9 @@ export class MessageReadReceiptSyncEngine {
     }
   }
 
-  private getSyncJob(subChannelId: string): Amity.ReadReceiptSyncJob | null {
-    const syncJobs = this.jobQueue;
-
-    const targetJob = syncJobs.find(job => job.subChannelId === subChannelId);
-
+  private getSyncJob(channelId: string): Amity.ReadReceiptSyncJob | null {
+    const { jobQueue } = this;
+    const targetJob = jobQueue.find(job => job.channelId === channelId);
     return targetJob || null;
   }
 
@@ -242,13 +224,6 @@ 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,6 +6,7 @@ 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,6 +30,14 @@ 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 };