@amityco/ts-sdk 7.1.1-a5f8c762.0 → 7.1.1-ce25d503.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":"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,YAmER,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-a5f8c762.0",
+  "version": "7.1.1-ce25d503.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

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/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

@@ -71,7 +71,7 @@ const updateChannelUnread = ({
       lastSegment: channels[i].messageCount,
       readToSegment,
       lastMentionedSegment,
-      unreadCount: channels[i].messageCount - readToSegment,
+      unreadCount: Math.max(channels[i].messageCount - readToSegment, 0),
       isMentioned: lastMentionedSegment > readToSegment,
       isDeleted: channels[i].isDeleted,
     });

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,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';
@@ -64,13 +64,16 @@ export const onMessageCreatedMqtt = (
           ? message.segment
           : channelUnread.lastMentionSegment;
 
-        pushToCache(['channelUnread', 'get', message.channelId], {
+        const updatedChannelUnread = {
           ...channelUnread,
           lastSegment,
-          unreadCount: lastSegment - channelUnread.readToSegment,
+          unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0),
           lastMentionSegment,
           isMentioned: !(channelUnread.readToSegment >= lastMentionSegment),
-        });
+        };
+
+        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/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.channelUnreadInfo.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,iCAAiC,CAAC,CAAC,KACxE,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.channelUnreadInfo.updated']>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.Events['local.channelUnreadInfo.updated']) => {
-    callback(payload);
-  };
-
-  return createEventSubscriber(
-    client,
-    'channel/onChannelUnreadUpdatedLocal',
-    'local.channelUnreadInfo.updated',
-    filter,
-  );
-};