@amityco/ts-sdk 7.1.1-207e990f.0 → 7.1.1-53d7c83.0

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,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-207e990f.0",
+  "version": "7.1.1-53d7c83.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

@@ -145,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/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

@@ -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/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.lastMentionSegment !== 'number'
+        )
+          return;
 
         const lastSegment = message.segment;
         const isMentionedInMessage = message.mentionedUsers?.some(mention => {
@@ -64,13 +71,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