@amityco/ts-sdk-react-native 6.32.2 → 6.32.3-89ca939.0

package/src/channelRepository/observers/observeChannel.ts

@@ -16,6 +16,7 @@ import {
   onChannelMemberRemoved,
 } from '../events';
 import { LinkedObject } from '~/utils/linkedObject';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js
@@ -43,25 +44,25 @@ export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType,
   log(`observeChannel(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.InternalChannel>, action: Events[number]) => {
+  const router = (result: Amity.Snapshot<Amity.StaticInternalChannel>, action: Events[number]) => {
     // filter function
     if (result.data?.channelId !== channelId) return;
 
     if (callback instanceof Function)
       return callback({
         ...result,
-        data: LinkedObject.channel(result.data),
+        data: LinkedObject.channel(constructChannelDynamicValue(result.data)),
       });
 
     if (action !== 'onFetch')
       callback.onEvent?.(action, {
         ...result,
-        data: LinkedObject.channel(result.data),
+        data: LinkedObject.channel(constructChannelDynamicValue(result.data)),
       });
 
     callback[action]?.({
       ...result,
-      data: LinkedObject.channel(result.data),
+      data: LinkedObject.channel(constructChannelDynamicValue(result.data)),
     });
   };
 

package/src/channelRepository/observers/observeChannels.ts

@@ -13,6 +13,7 @@ import {
   onChannelMemberRemoved,
 } from '../events';
 import { LinkedObject } from '~/utils/linkedObject';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js
@@ -40,13 +41,14 @@ export const observeChannels = (
   const disposers: Amity.Unsubscriber[] = [];
 
   const router = (
-    channel: Amity.InternalChannel,
+    channel: Amity.StaticInternalChannel,
     action: Exclude<Amity.ChannelActionType, 'onFetch'>,
   ) => {
-    if (callback instanceof Function) return callback(LinkedObject.channel(channel));
+    if (callback instanceof Function)
+      return callback(LinkedObject.channel(constructChannelDynamicValue(channel)));
 
-    callback.onEvent?.(action, LinkedObject.channel(channel));
-    callback[action]?.(LinkedObject.channel(channel));
+    callback.onEvent?.(action, LinkedObject.channel(constructChannelDynamicValue(channel)));
+    callback[action]?.(LinkedObject.channel(constructChannelDynamicValue(channel)));
   };
 
   disposers.push(

package/src/channelRepository/utils/constructChannelDynamicValue.ts

@@ -0,0 +1,22 @@
+import { shallowClone } from '~/utils/shallowClone';
+import { getChannelIsMentioned } from './getChannelIsMentioned';
+import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
+
+export const constructChannelDynamicValue = (
+  channel: Amity.StaticInternalChannel,
+): Amity.InternalChannel => {
+  return shallowClone(channel, {
+    get unreadCount() {
+      return getSubChannelsUnreadCount(channel);
+    },
+    get hasMentioned() {
+      return getChannelIsMentioned(channel);
+    },
+    get isMentioned() {
+      return getChannelIsMentioned(channel);
+    },
+    get subChannelsUnreadCount() {
+      return getSubChannelsUnreadCount(channel);
+    },
+  });
+};

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -16,7 +16,7 @@ export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =
 export function convertFromRaw(
   channel: Amity.RawChannel,
   options: { isMessagePreviewUpdated?: boolean } = { isMessagePreviewUpdated: true },
-): Amity.InternalChannel {
+): Amity.StaticInternalChannel {
   let { messagePreviewId } = channel;
 
   const messagePreviewChannelCache = pullFromCache<Amity.InternalMessagePreview>([
@@ -30,18 +30,6 @@ export function convertFromRaw(
   }
 
   return {
-    get unreadCount() {
-      return getSubChannelsUnreadCount(channel);
-    },
-    get hasMentioned() {
-      return getChannelIsMentioned(channel);
-    },
-    get isMentioned() {
-      return getChannelIsMentioned(channel);
-    },
-    get subChannelsUnreadCount() {
-      return getSubChannelsUnreadCount(channel);
-    },
     ...channel,
     defaultSubChannelId: channel.channelInternalId,
     isUnreadCountSupport: isUnreadCountSupport(channel),

package/src/channelRepository/utils/resolveUnreadInfoOnChannelEvent.ts

@@ -2,8 +2,8 @@ import { getActiveClient } from '~/client/api/activeClient';
 import ObjectResolverEngine from '~/client/utils/ObjectResolver/objectResolverEngine';
 
 export const resolveUnreadInfoOnChannelEvent = (
-  channel: Amity.InternalChannel,
-  callback: Amity.Listener<Amity.InternalChannel>,
+  channel: Amity.StaticInternalChannel,
+  callback: Amity.Listener<Amity.StaticInternalChannel>,
 ) => {
   const client = getActiveClient();
 

package/src/channelRepository/utils/updateChannelCache.ts

@@ -5,6 +5,6 @@ export function updateChannelCache(channel: Amity.Channel, params: Partial<Amity
   pushToCache(
     ['channel', 'get', channel.channelId],
     // eslint-disable-next-line prefer-object-spread
-    Object.assign(shallowClone(channel), params),
+    shallowClone(channel, params),
   );
 }

package/src/client/utils/removeChannelMarkerCache.ts

@@ -3,7 +3,7 @@ import { getResolver } from '~/core/model';
 
 import { getActiveUser } from '../api/activeUser';
 
-export const removeChannelMarkerCache = (channel: Amity.InternalChannel) => {
+export const removeChannelMarkerCache = (channel: Amity.StaticInternalChannel) => {
   const id = getResolver('channelMarker')({
     userId: getActiveUser()._id,
     entityId: channel.channelId,

package/src/communityRepository/communityMembership/events/utils.ts

@@ -73,7 +73,8 @@ export const createCommunityMemberEventSubscriber = (
       // TODO: here we are missing specific properties here!
       callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
     } else {
-      ingestInCache(preparedPayload);
+      // NOTE: The event payload should be merge with existing cache data
+      ingestInCache(preparedPayload, undefined, false);
 
       const community = pullFromCache<Amity.Community>([
         'community',
@@ -121,7 +122,8 @@ export const createLocalCommunityMemberEventSubscriber = (
       // TODO: here we are missing specific properties here!
       callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
     } else {
-      ingestInCache(preparedPayload);
+      // NOTE: The event payload should be merge with existing cache data
+      ingestInCache(preparedPayload, undefined, false);
 
       const community = pullFromCache<Amity.Community>([
         'community',

package/src/communityRepository/utils/communityWithMembership.ts

@@ -1,3 +1,4 @@
+import { pullFromCache } from '~/cache/api';
 import { getActiveUser } from '~/client';
 
 /*
@@ -21,21 +22,27 @@ function isCurrentUserPartOfCommunity(
 
 /*
  * For mqtt events server will not send user specific data as it's broadcasted
- * to multiple users. Althought this can be calculated, it's not scalable. Hence
- * the client SDK needs to calculate this info
+ * to multiple users and it also does not include communityUser
+ *
+ * Client SDK needs to check for the existing isJoined field in cache data before calculating.
+ * Althought this can be calculated, it's not scalable.
  */
 export function updateMembershipStatus(
   communities: Amity.Community[],
   communityUsers: Amity.Membership<'community'>[],
 ): Amity.Community[] {
   return communities.map(c => {
-    if (c.isJoined == null) {
-      const isJoined = communityUsers.some(
-        m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership),
-      );
-      return { ...c, isJoined };
+    const cachedCommunity = pullFromCache<Amity.Community>(['community', 'get', c.communityId]);
+    if (cachedCommunity?.data && cachedCommunity?.data.hasOwnProperty('isJoined')) {
+      return {
+        ...cachedCommunity.data,
+        ...c,
+      };
     }
 
-    return c;
+    const isJoined = communityUsers.some(
+      m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership),
+    );
+    return { ...c, isJoined };
   });
 }

package/src/marker/events/onMessageMarked.ts

@@ -4,8 +4,6 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api/activeClient';
 import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
-import { isObject } from '~/utils/object';
-import { shallowClone } from '~/utils/shallowClone';
 
 /**
  * ```js

package/src/marker/utils/reCalculateChannelUnreadInfo.ts

@@ -6,6 +6,8 @@ export const reCalculateChannelUnreadInfo = (channelId: string): Amity.ChannelUn
   const cacheChannelUnreadInfo =
     pullFromCache<Amity.ChannelUnreadInfo>(cacheKeyChannelUnread)?.data;
 
+  console.log('[reCalculateChannelUnreadInfo] cacheChannelUnreadInfo => ', cacheChannelUnreadInfo);
+
   const cacheKeySubChannelUnread = ['subChannelUnreadInfo', 'get'];
   const cachedSubChannelUnreadInfo =
     queryCache<Amity.SubChannelUnreadInfo>(cacheKeySubChannelUnread);
@@ -18,10 +20,14 @@ export const reCalculateChannelUnreadInfo = (channelId: string): Amity.ChannelUn
       return data.channelId === channelId && !data.isDeleted;
     });
 
+    console.log('[reCalculateChannelUnreadInfo] subChannelUnreadsInfo => ', subChannelUnreadsInfo);
+
     channelUnreads = subChannelUnreadsInfo
       .map(({ data }) => data.unreadCount)
       .reduce((acc, cur) => acc + cur, 0);
 
+    console.log('[reCalculateChannelUnreadInfo] channelUnreads => ', channelUnreads);
+
     isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
   }
 

package/src/marker/utils/updateSubChannelUnreadFromMessage.ts

@@ -6,6 +6,7 @@ export const updateSubChannelUnreadFromMessage = (message: Amity.RawMessage) =>
   const cacheKeyUnreadCount = ['subChannelUnreadInfo', 'get', message.messageFeedId];
   const cachedUnreadCount = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKeyUnreadCount)?.data;
 
+  console.log('[updateSubChannelUnreadFromMessage] cachedUnreadCount => ', cachedUnreadCount);
   if (!cachedUnreadCount) return;
 
   const lastSegment =
@@ -15,6 +16,8 @@ export const updateSubChannelUnreadFromMessage = (message: Amity.RawMessage) =>
 
   const unreadCount = lastSegment - cachedUnreadCount.readToSegment;
 
+  console.log('[updateSubChannelUnreadFromMessage] unreadCount => ', unreadCount);
+
   let { lastMentionSegment } = cachedUnreadCount;
 
   if (message.mentionedUsers && message.mentionedUsers.length > 0) {
@@ -36,5 +39,12 @@ export const updateSubChannelUnreadFromMessage = (message: Amity.RawMessage) =>
     unreadCount: Math.max(unreadCount, 0),
   };
 
+  console.log(
+    '[updateSubChannelUnreadFromMessage] updatedCachedUnreadCount => key',
+    cacheKeyUnreadCount,
+    'value =>',
+    updatedCachedUnreadCount,
+  );
+
   pushToCache(cacheKeyUnreadCount, updatedCachedUnreadCount);
 };

package/src/messageRepository/events/onMessageCreated.ts

@@ -32,6 +32,8 @@ export const onMessageCreatedMqtt = (
   const filter = async (rawPayload: Amity.MessagePayload) => {
     const payload = await prepareMessagePayload(rawPayload);
 
+    console.log('onMessageCreatedMqtt', payload);
+
     // update unreadCountInfo in cache
     if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
       rawPayload.messages.forEach(message => {

package/src/subChannelRepository/utils/updateSubChannelCache.ts

@@ -9,6 +9,6 @@ export function updateSubChannelCache(
   pushToCache(
     ['subChannel', 'get', subChannelId],
     // eslint-disable-next-line prefer-object-spread
-    Object.assign(shallowClone(subChannel), params),
+    shallowClone(subChannel, params),
   );
 }

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -1,8 +1,8 @@
 import { markAsRead } from '~/channelRepository/api/markAsRead';
+import { shallowClone } from '../shallowClone';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
-  return {
-    ...channel,
+  return shallowClone(channel, {
     markAsRead: () => markAsRead(channel.channelInternalId),
-  };
+  });
 };

package/src/utils/shallowClone.ts

@@ -12,9 +12,12 @@
  * @category utility
  * @private
  */
-export function shallowClone(obj: any) {
-  const clone = Object.create(Object.getPrototypeOf(obj));
-  const descriptors = Object.getOwnPropertyDescriptors(obj);
-  Object.defineProperties(clone, descriptors);
-  return clone;
+export function shallowClone(source: object, target: object) {
+  return Object.create(
+    Object.getPrototypeOf(source), // Use the prototype of the source object
+    {
+      ...Object.getOwnPropertyDescriptors(source), // Copy all descriptors (methods, properties) from the source
+      ...Object.getOwnPropertyDescriptors(target), // Merge/override with descriptors (getters, properties) from the target
+    },
+  );
 }