@amityco/ts-sdk 7.1.1-e887d15f.0 → 7.2.0

package/dist/messageRepository/events/onMessageCreated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onMessageCreated.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/events/onMessageCreated.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,aACrB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YAgER,CAAC;AAEF,eAAO,MAAM,qBAAqB,aACtB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YAoBR,CAAC"}
+{"version":3,"file":"onMessageCreated.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/events/onMessageCreated.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,aACrB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YA0ER,CAAC;AAEF,eAAO,MAAM,qBAAqB,aACtB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YAoBR,CAAC"}

package/dist/messageRepository/observers/getMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/observers/getMessage.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,cACV,MAAM,OAAO,CAAC,WAAW,CAAC,YAC3B,MAAM,kBAAkB,CAAC,MAAM,OAAO,CAAC,KAChD,MAAM,YAmBR,CAAC"}
+{"version":3,"file":"getMessage.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/observers/getMessage.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,cACV,MAAM,OAAO,CAAC,WAAW,CAAC,YAC3B,MAAM,kBAAkB,CAAC,MAAM,OAAO,CAAC,KAChD,MAAM,YAmBR,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.1.1-e887d15f.0",
+  "version": "7.2.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/domains/channel.ts

@@ -145,9 +145,9 @@ declare global {
       channelId: Amity.Channel['channelId'];
       unreadCount: number;
       isMentioned: boolean;
-      readToSegment: number;
+      readToSegment: number | null;
       lastSegment: number;
-      lastMentionSegment: number;
+      lastMentionedSegment: number | null;
       isDeleted: boolean;
     };
   }

package/src/@types/domains/client.ts

@@ -36,6 +36,7 @@ declare global {
 
       log: Logger;
       http: AxiosInstance;
+      upload: AxiosInstance;
       mqtt?: Amity.MqttClient;
       ws?: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;

package/src/channelRepository/events/onChannelDeleted.ts

@@ -6,7 +6,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareChannelPayload } from '../utils/prepareChannelPayload';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
-import { dropFromCache } from '~/cache/api';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
 
 type CallbackFn = (channel: Amity.StaticInternalChannel) => void;
 const callbacks: CallbackFn[] = [];
@@ -37,7 +37,14 @@ export const onChannelDeleted = (callback: Amity.Listener<Amity.StaticInternalCh
           addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
           deleteChannelUnreadByChannelId(channel.channelId);
         } else if (isLegacyUnreadCount) {
-          dropFromCache(['channelUnread', 'get', channel.channelId]);
+          const cacheKey = ['channelUnread', 'get', channel.channelId];
+          const cache = pullFromCache<Amity.ChannelUnread>(cacheKey);
+          if (cache) {
+            pushToCache(cacheKey, {
+              ...cache,
+              isDeleted: true,
+            });
+          }
         }
       });
 

package/src/channelRepository/internalApi/getTotalChannelsUnread.ts

@@ -0,0 +1,38 @@
+import { queryCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ *
+ * Calculate user unread from {@link Amity.ChannelUnread} objects
+ *
+ * @returns the {@link Amity.UserUnread} objects
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const getTotalChannelsUnread = (): Amity.Cached<Amity.UserUnread> => {
+  const client = getActiveClient();
+  client.log('channel/getTotalChannelsUnread.locally');
+
+  const cachedChannelsUnread =
+    queryCache<Amity.ChannelUnread>(['channelUnread', 'get'])?.filter(({ data }) => {
+      return !data.isDeleted;
+    }) || [];
+
+  const totalChannelsUnread: Amity.UserUnread = cachedChannelsUnread?.reduce(
+    (acc, { data }) => {
+      acc.unreadCount += data.unreadCount;
+      acc.isMentioned = acc.isMentioned || data.isMentioned;
+      return acc;
+    },
+    { unreadCount: 0, isMentioned: false as boolean },
+  ) || { unreadCount: 0, isMentioned: false };
+
+  const cachedAt = client.cache && Date.now();
+
+  return {
+    data: totalChannelsUnread,
+    cachedAt,
+  };
+};

package/src/channelRepository/observers/getTotalChannelsUnread.ts

@@ -0,0 +1,129 @@
+import { getActiveUser } from '~/client/api/activeUser';
+import { getTotalChannelsUnread as _getTotalChannelsUnread } from '../internalApi/getTotalChannelsUnread';
+import { onChannelUnreadUpdatedLocal } from '../events/onChannelUnreadUpdatedLocal';
+import { ASCApiError, ASCError } from '~/core/errors';
+import { getActiveClient } from '~/client';
+import { convertGetterPropsToStatic } from '~/utils/object';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+import { isEqual } from '~/utils/isEqual';
+
+/* begin_public_function
+  id: totalChannelsUnread.get
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk';
+ *
+ * let totalChannelsUnread;
+ *
+ * const unsubscribe = ChannelRepository.getTotalChannelsUnread(response => {
+ *   unread = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.UserUnread}
+ *
+ * @returns An {@link Amity.UserUnread} function to run when willing to stop observing the message
+ *
+ * @category User Unread Live Object
+ *
+ */
+
+export const getTotalChannelsUnread = (
+  callback: Amity.LiveObjectCallback<Amity.UserUnread | undefined>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Object feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveTotalChannelsUnread(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  let isUnsyncedModel = false; // for messages
+
+  let model: Amity.UserUnread | undefined;
+
+  const dispatcher = (data: Amity.LiveObject<Amity.UserUnread | undefined>) => {
+    const { data: userUnread } = data;
+
+    const callbackModel = userUnread
+      ? {
+          unreadCount: userUnread.unreadCount,
+          isMentioned: userUnread.isMentioned,
+        }
+      : undefined;
+
+    model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
+
+    callback({
+      data: callbackModel
+        ? { ...callbackModel, isMentioned: callbackModel.isMentioned }
+        : callbackModel,
+
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (userUnread: Amity.UserUnread) => {
+    if (isEqual(model, userUnread)) return;
+
+    dispatcher({
+      loading: false,
+      data: userUnread,
+    });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(async () => _getTotalChannelsUnread());
+
+    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedModel = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedModel) {
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(onChannelUnreadUpdatedLocal(realtimeRouter));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channelRepository/observers/index.ts

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

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -58,23 +58,34 @@ const updateChannelUnread = ({
 }) => {
   for (let i = 0; i < channels.length; i += 1) {
     const cacheKey = ['channelUnread', 'get', channels[i].channelId];
-    const { readToSegment, lastMentionedSegment } = channelUsers.find(
+    const channelUser = channelUsers.find(
       channelUser =>
         channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId,
-    ) || {
-      readToSegment: 0,
-      lastMentionedSegment: 0,
-    };
+    );
+
+    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;
+    }
 
-    pushToCache(cacheKey, {
+    const cacheChannelUnread: Amity.ChannelUnread = {
       channelId: channels[i].channelId,
       lastSegment: channels[i].messageCount,
       readToSegment,
       lastMentionedSegment,
-      unreadCount: channels[i].messageCount - readToSegment,
-      isMentioned: lastMentionedSegment > readToSegment,
-      isDeleted: channels[i].isDeleted,
-    });
+      unreadCount,
+      isMentioned,
+      isDeleted: channels[i].isDeleted || false,
+    };
+
+    pushToCache(cacheKey, cacheChannelUnread);
   }
 };
 

package/src/client/api/createClient.ts

@@ -50,7 +50,7 @@ export const createClient = (
     rteEnabled = true,
   }: {
     debugSession?: string;
-    apiEndpoint?: { http?: string; mqtt?: string };
+    apiEndpoint?: { http?: string; mqtt?: string; upload?: string };
     prefixDeviceIdKey?: string;
     rteEnabled?: boolean;
   } = {},
@@ -63,9 +63,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;
@@ -105,6 +107,7 @@ export const createClient = (
     http,
     ws,
     mqtt,
+    upload,
     emitter,
 
     /*

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

@@ -158,7 +158,11 @@ export class MessageReadReceiptSyncEngine {
     const cacheKey = ['channelUnread', 'get', channelId];
     const channelUnread = pullFromCache<Amity.ChannelUnread>(cacheKey)?.data;
 
-    if (channelUnread && segment > channelUnread.readToSegment) {
+    if (
+      typeof channelUnread?.readToSegment === 'number' &&
+      channelUnread &&
+      segment > channelUnread.readToSegment
+    ) {
       channelUnread.readToSegment = segment;
       channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
 

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 };
 

package/src/commentRepository/events/utils.ts

@@ -53,6 +53,36 @@ export const createCommentEventSubscriber = (
               }
             }
           }
+        }
+
+        if (['comment.deleted'].includes(event)) {
+          // NOTE: skip deleting comment to parent comment children if it's the same user since we use the local event to update instead.
+          if (event === 'comment.deleted' && comment.data.userId === client.userId) return;
+
+          if (comments[0].parentId) {
+            const parentComment = pullFromCache<Amity.InternalComment>([
+              'comment',
+              'get',
+              comments[0].parentId,
+            ]);
+
+            if (parentComment?.data) {
+              // Remove deleted comment in parent childComment if still exists
+              if (parentComment.data.children.includes(comments[0].commentId)) {
+                const newParentComment = {
+                  ...parentComment.data,
+                  childrenNumber: parentComment.data.childrenNumber - 1,
+                  children: [
+                    ...new Set([
+                      ...parentComment.data.children.filter(id => id !== comments[0].commentId),
+                    ]),
+                  ],
+                };
+
+                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
+              }
+            }
+          }
 
           const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
             ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
@@ -135,6 +165,49 @@ export const createLocalCommentEventSubscriber = (
           queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
         }
 
+        if (['local.comment.deleted'].includes(event)) {
+          if (comments[0].parentId) {
+            const parentComment = pullFromCache<Amity.InternalComment>([
+              'comment',
+              'get',
+              comments[0].parentId,
+            ]);
+
+            if (parentComment?.data) {
+              // Remove deleted comment in parent childComment if still exists
+              if (parentComment.data.children.includes(comments[0].commentId)) {
+                const newParentComment = {
+                  ...parentComment.data,
+                  childrenNumber: parentComment.data.childrenNumber - 1,
+                  children: [
+                    ...new Set([
+                      ...parentComment.data.children.filter(id => id !== comments[0].commentId),
+                    ]),
+                  ],
+                };
+                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
+
+                setTimeout(() => {
+                  // NOTE: This is workaround solution for emitting event not work properly.
+                  fireEvent('comment.updated', {
+                    comments: [newParentComment],
+                    commentChildren: [],
+                    files: [],
+                    users: [],
+                    communityUsers: [],
+                  });
+                }, 200);
+              }
+            }
+          }
+
+          const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
+            ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
+          );
+
+          queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
+        }
+
         callback(LinkedObject.comment(comment.data));
       }
     }

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.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+  const { data } = await client.upload.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.http.post<Amity.CreateFilePayload<'image'>>(
+  const { data } = await client.upload.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.http.post<Amity.CreateFilePayload<'video'>>(
+  const { data } = await client.upload.post<Amity.CreateFilePayload<'video'>>(
     '/api/v4/videos',
     formData,
     {

package/src/messageRepository/events/onMessageCreated.ts

@@ -1,5 +1,5 @@
 import { getActiveClient } from '~/client/api/activeClient';
-import { createEventSubscriber } from '~/core/events';
+import { createEventSubscriber, fireEvent } from '~/core/events';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { updateSubChannelUnreadFromMessage } from '~/marker/utils/updateSubChannelUnreadFromMessage';
 import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
@@ -48,7 +48,14 @@ export const onMessageCreatedMqtt = (
           'get',
           message.channelId,
         ])?.data;
-        if (!channelUnread || channelUnread.lastSegment >= message.segment) return;
+
+        if (
+          !channelUnread ||
+          channelUnread.lastSegment >= message.segment ||
+          typeof channelUnread.readToSegment !== 'number' ||
+          typeof channelUnread.lastMentionedSegment !== 'number'
+        )
+          return;
 
         const lastSegment = message.segment;
         const isMentionedInMessage = message.mentionedUsers?.some(mention => {
@@ -60,17 +67,20 @@ export const onMessageCreatedMqtt = (
           );
         });
 
-        const lastMentionSegment = isMentionedInMessage
+        const lastMentionedSegment = isMentionedInMessage
           ? message.segment
-          : channelUnread.lastMentionSegment;
+          : channelUnread.lastMentionedSegment;
 
-        pushToCache(['channelUnread', 'get', message.channelId], {
+        const updatedChannelUnread: Amity.ChannelUnread = {
           ...channelUnread,
           lastSegment,
-          unreadCount: lastSegment - channelUnread.readToSegment,
-          lastMentionSegment,
-          isMentioned: !(channelUnread.readToSegment >= lastMentionSegment),
-        });
+          unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0),
+          lastMentionedSegment,
+          isMentioned: !(channelUnread.readToSegment >= lastMentionedSegment),
+        };
+
+        pushToCache(['channelUnread', 'get', message.channelId], updatedChannelUnread);
+        fireEvent('local.channelUnread.updated', updatedChannelUnread);
       });
     }
 

package/src/messageRepository/observers/getMessage.ts

@@ -13,7 +13,6 @@ import {
 } from '../events';
 import { onMessageFetched } from '../events/onMessageFetched';
 import { LinkedObject } from '~/utils/linkedObject';
-import { date } from '~/utils/tests';
 
 /* begin_public_function
   id: message.get