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

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

@@ -26,6 +26,8 @@ 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}`,

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/marker/events/onChannelUnreadInfoUpdatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.channelUnreadInfo} has been updated.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category ChannelMarker Events
+ */
+export const onChannelUnreadInfoUpdatedLocal = (
+  callback: Amity.Listener<Amity.Events['local.channelUnreadInfo.updated']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.channelUnreadInfo.updated']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'channelMarker/onChannelUnreadInfoUpdatedLocal',
+    'local.channelUnreadInfo.updated',
+    filter,
+  );
+};

package/src/messageRepository/events/onMessageCreated.ts

@@ -1,11 +1,12 @@
 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';
 import { getActiveUser } from '~/client/api/activeUser';
 import { markReadMessage } from '../utils/markReadMessage';
 import { prepareMessagePayload } from '../utils';
+import { pullFromCache, pushToCache } from '~/cache/api';
 
 /**
  * ```js
@@ -40,6 +41,49 @@ export const onMessageCreatedMqtt = (
       });
     }
 
+    if (client.useLegacyUnreadCount) {
+      rawPayload.messages.forEach(message => {
+        const channelUnread = pullFromCache<Amity.ChannelUnread>([
+          'channelUnread',
+          'get',
+          message.channelId,
+        ])?.data;
+
+        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 => {
+          return (
+            mention.type === 'channel' ||
+            (mention.type === 'user' &&
+              client.userId &&
+              mention.userPublicIds.includes(client.userId))
+          );
+        });
+
+        const lastMentionedSegment = isMentionedInMessage
+          ? message.segment
+          : channelUnread.lastMentionedSegment;
+
+        const updatedChannelUnread: Amity.ChannelUnread = {
+          ...channelUnread,
+          lastSegment,
+          unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0),
+          lastMentionedSegment,
+          isMentioned: !(channelUnread.readToSegment >= lastMentionedSegment),
+        };
+
+        pushToCache(['channelUnread', 'get', message.channelId], updatedChannelUnread);
+        fireEvent('local.channelUnread.updated', updatedChannelUnread);
+      });
+    }
+
     // Update in cache
     ingestInCache(payload);
 

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/messageRepository/utils/markReadMessage.ts

@@ -1,8 +1,15 @@
+import { getActiveClient } from '~/client/api/activeClient';
 import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
+import LegacyReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine';
 
 export const markReadMessage = (message: Amity.InternalMessage) => {
-  const { subChannelId, channelSegment } = message;
-  const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
+  const client = getActiveClient();
 
-  markReadReceiptEngine.markRead(subChannelId, channelSegment);
+  if (client.useLegacyUnreadCount) {
+    const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
+    markReadReceiptEngine.markRead(message.channelId, message.channelSegment);
+  } else {
+    const markReadReceiptEngine = LegacyReadReceiptSyncEngine.getInstance();
+    markReadReceiptEngine.markRead(message.subChannelId, message.channelSegment);
+  }
 };

package/src/reactionRepository/api/addReaction.ts

@@ -5,6 +5,7 @@ import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { dispatchReactable } from '../utils';
 import { fireEvent } from '~/core/events';
+import { ASCApiError } from '~/core/errors';
 
 /* begin_public_function
   id: reaction.add
@@ -37,6 +38,13 @@ export const addReaction = async (
     reactionName,
   });
 
+  if (!['post', 'comment', 'story', 'message'].includes(referenceType))
+    throw new ASCApiError(
+      'The reference type is not valid. It should be one of post, comment, story, or message',
+      Amity.ServerError.BAD_REQUEST,
+      Amity.ErrorLevel.ERROR,
+    );
+
   const { data } = await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
     referenceId,
     referenceType,

package/src/reactionRepository/api/removeReaction.ts

@@ -6,6 +6,7 @@ import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 
 import { dispatchReactable } from '../utils';
 import { fireEvent } from '~/core/events';
+import { ASCApiError } from '~/core/errors';
 
 /* begin_public_function
   id: reaction.remove
@@ -38,6 +39,13 @@ export const removeReaction = async (
     reactionName,
   });
 
+  if (!['post', 'comment', 'story', 'message'].includes(referenceType))
+    throw new ASCApiError(
+      'The reference type is not valid. It should be one of post, comment, story, or message',
+      Amity.ServerError.BAD_REQUEST,
+      Amity.ErrorLevel.ERROR,
+    );
+
   const { data } = await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
     data: {
       referenceId,

package/src/reactionRepository/observers/getReactions/ReactionPaginationController.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client';
 import { PaginationController } from '~/core/liveCollection/PaginationController';
 import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
 import { REFERENCE_API_V5 } from '~/reactionRepository/api/constants';
+import { ASCApiError } from '~/core/errors';
 
 export class ReactionPaginationController extends PaginationController<
   'reaction',
@@ -15,6 +16,13 @@ export class ReactionPaginationController extends PaginationController<
 
     const path = '/api/v3/reactions';
 
+    if (!['post', 'comment', 'story', 'message'].includes(params.referenceType))
+      throw new ASCApiError(
+        'The reference type is not valid. It should be one of post, comment, story, or message',
+        Amity.ServerError.BAD_REQUEST,
+        Amity.ErrorLevel.ERROR,
+      );
+
     const { data: queryResponse } = await this.http.get<Amity.ReactionPayload & Amity.Pagination>(
       path,
       {

package/dist/marker/events/onChannelUnreadUpdatedLocal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onChannelUnreadUpdatedLocal.d.ts","sourceRoot":"","sources":["../../../src/marker/events/onChannelUnreadUpdatedLocal.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B,aAC5B,MAAM,QAAQ,CAAC,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC,KACpE,MAAM,YAaR,CAAC"}