@amityco/ts-sdk 7.1.1-c8d4edca.0 → 7.1.1-dbdbe662.0

package/dist/marker/events/onChannelUnreadInfoUpdatedLocal.d.ts

@@ -1,12 +1,12 @@
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ * 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 MessageMarker Events
+ * @category ChannelMarker Events
  */
 export declare const onChannelUnreadInfoUpdatedLocal: (callback: Amity.Listener<Amity.Events['local.channelUnreadInfo.updated']>) => Amity.Unsubscriber;
 //# sourceMappingURL=onChannelUnreadInfoUpdatedLocal.d.ts.map

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":"AASA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,aACrB,MAAM,QAAQ,CAAC,MAAM,eAAe,CAAC,KAC9C,MAAM,YA+BR,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-c8d4edca.0",
+  "version": "7.1.1-dbdbe662.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

@@ -84,6 +84,8 @@ declare global {
     > & {
       isMentioned: boolean;
       subChannelsUnreadCount: number;
+      // legacy unread count does not use the maker service
+      unreadCount: number;
     };
 
     /* public type */
@@ -143,9 +145,9 @@ declare global {
       channelId: Amity.Channel['channelId'];
       unreadCount: number;
       isMentioned: boolean;
-      readToSegment: number;
+      readToSegment: number | null;
       lastSegment: number;
-      lastMentionSegment: number;
+      lastMentionSegment: number | null;
       isDeleted: boolean;
     };
   }

package/src/channelRepository/events/onChannelDeleted.ts

@@ -6,6 +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, pullFromCache, pushToCache } from '~/cache/api';
 
 type CallbackFn = (channel: Amity.StaticInternalChannel) => void;
 const callbacks: CallbackFn[] = [];
@@ -28,12 +29,24 @@ export const onChannelDeleted = (callback: Amity.Listener<Amity.StaticInternalCh
     const filter = async (payload: Amity.ChannelPayload) => {
       const data = await prepareChannelPayload(payload);
 
-      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        data.channels.forEach(channel => {
+      const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+      const isLegacyUnreadCount = client.useLegacyUnreadCount;
+
+      data.channels.forEach(channel => {
+        if (isConsistentMode) {
           addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
           deleteChannelUnreadByChannelId(channel.channelId);
-        });
-      }
+        } else if (isLegacyUnreadCount) {
+          const cacheKey = ['channelUnread', 'get', channel.channelId];
+          const cache = pullFromCache<Amity.ChannelUnread>(cacheKey);
+          if (cache) {
+            pushToCache(cacheKey, {
+              ...cache,
+              isDeleted: true,
+            });
+          }
+        }
+      });
 
       ingestInCache(data);
       callbacks.forEach(cb => cb(data.channels[0]));

package/src/channelRepository/events/onChannelLeft.ts

@@ -6,6 +6,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareChannelPayload } from '../utils';
 import { deleteChannelUnreadByChannelId } from '../../marker/utils/deleteChannelUnreadByChannelId';
 import { addFlagIsDeletedSubChannelUnreadByChannelId } from '~/marker/utils/addFlagIsDeletedSubChannelUnreadByChannelId';
+import { dropFromCache } from '~/cache/api';
 
 type CallbackFn = (
   channel: Amity.StaticInternalChannel,
@@ -40,10 +41,17 @@ export const onChannelLeft = (
         isMessagePreviewUpdated: isLeftByMe,
       });
 
-      if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode() && isLeftByMe) {
+      const isConsistentMode = client.getMarkerSyncConsistentMode() && client.isUnreadCountEnabled;
+      const isLegacyUnreadCount = client.useLegacyUnreadCount;
+
+      if (isLeftByMe) {
         preparedPayload.channels.forEach(channel => {
-          addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
-          deleteChannelUnreadByChannelId(channel.channelId);
+          if (isConsistentMode) {
+            addFlagIsDeletedSubChannelUnreadByChannelId(channel.channelId);
+            deleteChannelUnreadByChannelId(channel.channelId);
+          } else if (isLegacyUnreadCount) {
+            dropFromCache(['channelUnread', 'get', channel.channelId]);
+          }
         });
       }
 

package/src/channelRepository/events/onChannelUnreadUpdatedLocal.ts

@@ -4,12 +4,12 @@ import { createEventSubscriber } from '~/core/events';
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ * Fired when an {@link Amity.ChannelUnread} has been updated.
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category MessageMarker Events
+ * @category Channel Events
  */
 export const onChannelUnreadUpdatedLocal = (
   callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>,

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,21 +58,30 @@ 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, {
       channelId: channels[i].channelId,
       lastSegment: channels[i].messageCount,
       readToSegment,
       lastMentionedSegment,
-      unreadCount: channels[i].messageCount - readToSegment,
-      isMentioned: lastMentionedSegment > readToSegment,
+      unreadCount,
+      isMentioned,
       isDeleted: channels[i].isDeleted,
     });
   }

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

@@ -38,7 +38,6 @@ export class MessageReadReceiptSyncEngine {
     if (this.jobQueue.length === 0 || this.isActive === false) return;
 
     const readReceipts = this.getReadReceipts();
-    console.log('[New 🌟 readReceipts] Sync read receipts', readReceipts);
     if (readReceipts) {
       this.markReadApi(readReceipts);
     }
@@ -159,9 +158,11 @@ export class MessageReadReceiptSyncEngine {
     const cacheKey = ['channelUnread', 'get', channelId];
     const channelUnread = pullFromCache<Amity.ChannelUnread>(cacheKey)?.data;
 
-    console.log('[New 🌟] Mark read => channel unread', channelUnread);
-
-    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/marker/events/onChannelUnreadInfoUpdatedLocal.ts

@@ -4,12 +4,12 @@ import { createEventSubscriber } from '~/core/events';
 /**
  * Internal used only
  *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ * 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 MessageMarker Events
+ * @category ChannelMarker Events
  */
 export const onChannelUnreadInfoUpdatedLocal = (
   callback: Amity.Listener<Amity.Events['local.channelUnreadInfo.updated']>,

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.lastMentionSegment !== '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 lastMentionSegment = isMentionedInMessage
+          ? message.segment
+          : channelUnread.lastMentionSegment;
+
+        const updatedChannelUnread = {
+          ...channelUnread,
+          lastSegment,
+          unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0),
+          lastMentionSegment,
+          isMentioned: !(channelUnread.readToSegment >= lastMentionSegment),
+        };
+
+        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/dist/marker/events/onChannelUnreadUpdatedLocal.d.ts

@@ -1,12 +0,0 @@
-/**
- * Internal used only
- *
- * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category MessageMarker Events
- */
-export declare const onChannelUnreadUpdatedLocal: (callback: Amity.Listener<Amity.Events['local.channelUnread.updated']>) => Amity.Unsubscriber;
-//# sourceMappingURL=onChannelUnreadUpdatedLocal.d.ts.map

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

package/src/marker/events/onChannelUnreadUpdatedLocal.ts

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