@amityco/ts-sdk 7.1.1-e887d15f.0 → 7.2.1-3663404.0

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/core/model/idResolvers.ts

@@ -61,6 +61,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/index.ts

@@ -4,3 +4,4 @@ export * from './deleteFile';
 export * from './fileUrlWithSize';
 export * from './uploadVideo';
 export * from './uploadImage';
+export * from './updateAltText';

package/src/fileRepository/api/updateAltText.ts

@@ -0,0 +1,39 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+
+/* begin_public_function
+  id: file.update.altText
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const updated = await FileRepository.updateAltText(fileId, altText)
+ * ```
+ *
+ * Updates an {@link Amity.File<'image'>['altText']}.
+ *
+ * @param fileId The ID of the {@link Amity.File<'image'>} to edit
+ * @param altText The new alt text for the {@link Amity.File<'image'>}
+ * @returns the updated {@link Amity.File<'image'>} object
+ *
+ * @category File API
+ * @async
+ */
+export const updateAltText = async (
+  fileId: Amity.File['fileId'],
+  altText: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('file/updateAltText', altText);
+
+  const { data } = await client.http.put<Amity.FilePayload<'image'>>(`/api/v3/files/${fileId}`, {
+    altText,
+  });
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache({ files: [data] }, { cachedAt });
+
+  return true;
+};
+/* end_public_function */

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

@@ -16,33 +16,52 @@ import GlobalFileAccessType from '~/client/utils/GlobalFileAccessType';
  *
  * @param formData The data necessary to create a new {@link Amity.File<'image'>}
  * @param onProgress The callback to track the upload progress
+ * @param altText The alt text for the image
  * @returns The newly created {@link Amity.File<'image'>}
  *
  * @category File API
  * @async
  */
+
 export const uploadImage = async (
   formData: FormData,
   onProgress?: (percent: number) => void,
+  altText?: string,
 ): Promise<Amity.Cached<Amity.File<'image'>[]>> => {
   const client = getActiveClient();
   client.log('file/uploadImage', formData);
 
   const files = formData.getAll('files');
 
-  if (!files.length) throw new Error('The formData object must have a `files` key.');
+  if (files?.length) {
+    console.warn('Deprecation Warning: `files` is deprecated, please use `file` instead.');
+
+    formData.append('preferredFilename', (files[0] as File).name);
+  } else {
+    const file = formData.get('file') as File;
+
+    if (!file) {
+      throw new Error('The formData object must have a `file` or `files` key');
+    }
+
+    formData.append('preferredFilename', file.name);
+
+    // alt is for single image
+    if (altText) {
+      formData.append('altText', altText);
+    }
+  }
 
   const accessType = GlobalFileAccessType.getInstance().getFileAccessType();
-  formData.append('accessType', accessType);
 
-  formData.append('preferredFilename', (files[0] as File).name);
+  formData.append('accessType', accessType);
 
   const headers =
     'getHeaders' in formData
       ? (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/index.ts

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

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

package/src/notificationTray/api/index.ts

@@ -0,0 +1,2 @@
+export * from './markItemsSeen';
+export * from './markTraySeen';

package/src/notificationTray/api/markItemsSeen.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTrayItem.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markItemsSeen()
+ * ```
+ *
+ * Updates an {@link Amity.NotificationItemSeen}
+ *
+ * @param trayItems[] that include id and lastTraySeenAt, The ID of the {@link Amity.NotificationItemSeen} to edit
+ * @returns the updated {@link Amity.NotificationItemSeen} object
+ *
+ * @category NotificationItemSeen API
+ * @async
+ */
+export const markItemsSeen = async (trayItems: Amity.QueryNotificationItemSeen[]) => {
+  const client = getActiveClient();
+  client.log('notificationTray/markItemsSeen', {});
+
+  const { data: payload } = await client.http.post<Amity.NotificationItemSeenPayload>(
+    `api/v1/notification-tray/items/seen`,
+    {
+      trayItems: trayItems.map(item => ({
+        id: item.id,
+        lastSeenAt: item.lastSeenAt,
+      })),
+    },
+  );
+
+  const updatedData = trayItems
+    .map(patchItem => {
+      const cacheData = pullFromCache<Amity.InternalNotificationTrayItem>([
+        'notificationTrayItem',
+        'get',
+        patchItem.id,
+      ])?.data;
+
+      if (!cacheData) return;
+
+      const data = {
+        ...cacheData,
+        ...payload,
+      };
+
+      if (client.cache) {
+        const cachedAt = Date.now();
+        pushToCache(['notificationTrayItem', 'get'], data, { cachedAt });
+      }
+
+      return data;
+    })
+    .filter(Boolean) as Amity.InternalNotificationTrayItem[];
+
+  fireEvent('local.notificationTrayItem.updated', { notificationTrayItems: updatedData });
+};
+/* end_public_function */

package/src/notificationTray/api/markTraySeen.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markTraySeen({
+ *   lastSeenAt: Amity.timestamp,
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.NotificationTraySeen}
+ *
+ * @param userId The ID of the {@link Amity.NotificationTraySeen} to edit
+ * @param lastSeenAt The patch data to apply
+ * @returns the updated {@link Amity.NotificationTraySeen} object
+ *
+ * @category Post API
+ * @async
+ */
+export const markTraySeen = async (
+  lastSeenAt: Amity.timestamp,
+): Promise<Amity.Cached<Amity.NotificationTraySeenUpdatedPayload>> => {
+  const client = getActiveClient();
+  client.log('notificationTray/markTraySeen', {});
+
+  const { data: payload } = await client.http.post<Amity.NotificationTraySeenUpdatedPayload>(
+    `api/v1/notification-tray/tray/seen`,
+    {
+      lastSeenAt,
+    },
+  );
+
+  const cacheData = pullFromCache<Amity.InternalNotificationTraySeen>([
+    'notificationTraySeen',
+    'get',
+  ])?.data;
+
+  const data = {
+    userId: client.userId!,
+    lastTraySeenAt: payload.lastSeenAt,
+  } as Amity.InternalNotificationTraySeen;
+
+  const updateCacheData = {
+    ...cacheData,
+    ...data,
+  };
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache)
+    pushToCache(['notificationTraySeen', 'get', client.userId!], updateCacheData, { cachedAt });
+
+  fireEvent('local.notificationTraySeen.updated', data);
+
+  return {
+    data: payload,
+    cachedAt,
+  };
+};
+/* end_public_function */