@amityco/ts-sdk-react-native 6.22.1-cbca8f1.0 → 6.23.1-d8b4c4c.0

package/src/communityRepository/observers/searchCommunities/SearchCommunitiesLiveCollectionController.ts

@@ -0,0 +1,129 @@
+/* eslint-disable no-use-before-define */
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CommunitiesPaginationController } from './SearchCommunitiesPaginationController';
+import { CommunitiesQueryStreamController } from './SearchCommunitiesQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommunityCreated,
+  onCommunityDeleted,
+  onCommunityUpdated,
+} from '~/communityRepository/events';
+import {
+  filterByCommunityMembership,
+  filterByPropEquality,
+  sortByDisplayName,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+import { getActiveClient } from '~/client';
+import { EnumCommunityActions } from './enums';
+
+export class SearchCommunityLiveCollectionController extends LiveCollectionController<
+  'community',
+  Amity.SearchCommunityLiveCollection,
+  Amity.Community,
+  CommunitiesPaginationController
+> {
+  private queryStreamController: CommunitiesQueryStreamController;
+
+  private query: Amity.SearchCommunityLiveCollection;
+
+  constructor(
+    query: Amity.SearchCommunityLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Community>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['community', 'collection', queryStreamId];
+    const paginationController = new CommunitiesPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CommunitiesQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.SearchCommunityLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommunityPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'community'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommunityDeleted, action: EnumCommunityActions.OnCommunityDeleted },
+      { fn: onCommunityUpdated, action: EnumCommunityActions.OnCommunityUpdated },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.SearchCommunityLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Community>(['community', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Community[]) {
+    const { userId } = getActiveClient();
+
+    let communities = data;
+
+    if (this.query.includeDeleted) {
+      communities = filterByPropEquality(communities, 'isDeleted', false);
+    }
+
+    if (this.query.categoryId) {
+      communities = communities.filter(c => c.categoryIds?.includes(this.query.categoryId!));
+    }
+
+    if (this.query.tags) {
+      communities = communities.filter(c => c.tags?.some(t => this.query.tags?.includes(t)));
+    }
+
+    if (this.query.membership && userId) {
+      communities = filterByCommunityMembership(communities, this.query.membership, userId);
+    }
+
+    return communities;
+  }
+}

package/src/communityRepository/observers/searchCommunities/SearchCommunitiesPaginationController.ts

@@ -0,0 +1,31 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class CommunitiesPaginationController extends PaginationController<
+  'community',
+  Amity.SearchCommunityLiveCollection
+> {
+  async getRequest(queryParams: Amity.SearchCommunityLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.CommunityPayload & Amity.Pagination>(
+      `/api/v3/communities`,
+      {
+        params: {
+          ...params,
+          isDeleted: inferIsDeleted(params.includeDeleted),
+          keyword: params.displayName,
+          filter: params.membership,
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/communityRepository/observers/searchCommunities/SearchCommunitiesQueryStreamController.ts

@@ -0,0 +1,81 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+import { EnumCommunityActions } from './enums';
+
+export class CommunitiesQueryStreamController extends QueryStreamController<
+  Amity.CommunityPayload,
+  Amity.SearchCommunityLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.CommunityPayload) => Amity.ProcessedCommunityPayload;
+
+  constructor(
+    query: Amity.SearchCommunityLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.CommunityPayload) => Amity.ProcessedCommunityPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommunityPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommunityPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.communities.map(getResolver('community')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.SearchCommunityLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const communities = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...communities, ...response.communities.map(getResolver('community'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumCommunityActions) {
+    return (community: Amity.Community) => {
+      const collection = pullFromCache<Amity.SearchCommunityLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (channel: Amity.Community) => void) => Amity.Unsubscriber;
+      action: EnumCommunityActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/communityRepository/observers/searchCommunities/enums.ts

@@ -0,0 +1,5 @@
+export enum EnumCommunityActions {
+  OnCommunityCreated = 'onCommunityCreated',
+  OnCommunityDeleted = 'onCommunityDeleted',
+  OnCommunityUpdated = 'onCommunityUpdated',
+}

package/src/communityRepository/observers/searchCommunities.ts

@@ -0,0 +1,56 @@
+import { dropFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { SearchCommunityLiveCollectionController } from './searchCommunities/SearchCommunitiesLiveCollectionController';
+
+/* begin_public_function
+  id: community.query
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk-react-native'
+ *
+ * let communities = []
+ * const unsub = CommunityRepository.searchCommunities({
+ *   displayName: Amity.Community['displayName'],
+ * }, response => merge(communities, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Community}s
+ *
+ * @param params for querying communities
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the communities
+ *
+ * @category Community Live Collection
+ */
+export const searchCommunities = (
+  params: Amity.CommunityLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Community>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`searchCommunities(tmpid: ${timestamp}) > listen`);
+
+  const searchCommunitiesLiveCollection = new SearchCommunityLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = searchCommunitiesLiveCollection.startSubscription();
+
+  const cacheKey = searchCommunitiesLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`searchCommunities(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/communityRepository/utils/payload.ts

@@ -1,4 +1,5 @@
 import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+import { pullFromCache } from '~/cache/api';
 import { withUsers } from '~/group/utils';
 import { updateMembershipStatus } from './communityWithMembership';
 
@@ -13,6 +14,22 @@ const getMatchPostSetting = (value: {
       value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
   ) ?? DefaultCommunityPostSetting;
 
+const convertCommunityUsersToUniqueObject = (
+  communityUsers: Amity.RawMembership<'community'>[],
+) => {
+  if (!communityUsers) return communityUsers;
+
+  const result: {
+    [key: Amity.RawMembership<'community'>['userId']]: Amity.RawMembership<'community'>;
+  } = {};
+
+  communityUsers.forEach(user => {
+    result[user.userId] = user;
+  });
+
+  return result;
+};
+
 export const prepareCommunityPayload = (
   rawPayload: Amity.CommunityPayload,
 ): Amity.ProcessedCommunityPayload => {
@@ -27,7 +44,24 @@ export const prepareCommunityPayload = (
     }),
   );
 
-  const communityUsers = withUsers(rawPayload.communityUsers);
+  const mergeCommunityUsers = communities.reduce<{
+    [key: string]: Amity.RawMembership<'community'>;
+  }>((acc, { communityId }) => {
+    const users = pullFromCache<Amity.RawMembership<'community'>[]>([
+      'communityUsers',
+      'collection',
+      communityId,
+    ])?.data;
+
+    if (!users) return acc;
+
+    return {
+      ...convertCommunityUsersToUniqueObject(users),
+      ...acc,
+    };
+  }, convertCommunityUsersToUniqueObject(rawPayload.communityUsers));
+
+  const communityUsers = withUsers(Object.values(mergeCommunityUsers));
 
   const communityWithMembershipStatus = updateMembershipStatus(communities, communityUsers);
 

package/src/communityRepository/utils/saveCommunityUsers.ts

@@ -0,0 +1,16 @@
+import { pushToCache } from '~/cache/api';
+
+export const saveCommunityUsers = (
+  communities: Amity.CommunityPayload['communities'],
+  communityUsers: Amity.CommunityPayload['communityUsers'],
+) => {
+  if (communities.length === 0 || communityUsers.length === 0) return;
+
+  communities.forEach(({ communityId }) => {
+    const collection = communityUsers.filter(
+      ({ communityId: userCommunityId }) => communityId === userCommunityId,
+    );
+
+    pushToCache(['communityUsers', 'collection', communityId], collection);
+  });
+};

package/src/core/liveCollection/LiveCollectionController.ts

@@ -1,4 +1,4 @@
-import { convertGetterPropsToStatic } from '~/utils/object';
+import { convertGetterPropsToStatic, removeFunctionProperties } from '~/utils/object';
 import { isEqual } from '~/utils/isEqual';
 import { PaginationController } from './PaginationController';
 import { PaginationNoPageController } from './PaginationNoPageController';
@@ -57,10 +57,13 @@ export abstract class LiveCollectionController<
     }
   }
 
-  protected loadPage(
+  protected loadPage({
     initial = false,
-    direction: Amity.LiveCollectionPageDirection = Amity.LiveCollectionPageDirection.NEXT,
-  ) {
+    direction = Amity.LiveCollectionPageDirection.NEXT,
+  }: {
+    initial?: boolean;
+    direction?: Amity.LiveCollectionPageDirection;
+  }) {
     this.setup();
 
     this.notifyChange({ origin: Amity.LiveDataOrigin.LOCAL, loading: true });
@@ -129,9 +132,10 @@ export abstract class LiveCollectionController<
   abstract notifyChange(params: Amity.LiveCollectionNotifyParams): void;
 
   protected shouldNotify(data: TPublicPayload[]) {
-    if (isEqual(this.snapshot, data)) return false;
+    const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
+    if (isEqual(this.snapshot, newData)) return false;
 
-    this.snapshot = data.map(payload => convertGetterPropsToStatic(payload)) as TPublicPayload[];
+    this.snapshot = newData as TPublicPayload[];
     return true;
   }
 

package/src/core/model/idResolvers.ts

@@ -44,6 +44,7 @@ const idResolvers: Resolvers = {
   reactor: ({ reactionId }) => reactionId,
 
   stream: ({ streamId }) => streamId,
+  streamModeration: ({ streamId }) => streamId,
 
   follow: ({ from, to }) => `${from}#${to}`,
   followInfo: ({ userId }) => userId,

package/src/core/model/index.ts

@@ -41,6 +41,7 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   reactions: 'reaction',
 
   videoStreamings: 'stream',
+  videoStreamModerations: 'streamModeration',
 
   follows: 'follow',
   followCounts: 'followCount',

package/src/fileRepository/api/uploadFile.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { rebuildFormDataWithMimeType } from '~/fileRepository/utils/rebuildFormDataWithMimeType';
 
 /* begin_public_function
   id: file.upload.file
@@ -36,16 +35,12 @@ 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',
-    rebuildFormDataWithMimeType(formData),
-    {
-      headers,
-      onUploadProgress({ loaded, total = 100 }) {
-        onProgress && onProgress(Math.round((loaded * 100) / total));
-      },
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+    headers,
+    onUploadProgress({ loaded, total = 100 }) {
+      onProgress && onProgress(Math.round((loaded * 100) / total));
     },
-  );
+  });
 
   // API-FIX: payload should be serialized properly
   // const { files } = data

package/src/fileRepository/api/uploadImage.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { rebuildFormDataWithMimeType } from '../utils/rebuildFormDataWithMimeType';
 
 /* begin_public_function
   id: file.upload.image
@@ -38,7 +37,7 @@ export const uploadImage = async (
 
   const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
     '/api/v4/images',
-    rebuildFormDataWithMimeType(formData),
+    formData,
     {
       headers,
       onUploadProgress({ loaded, total = 100 }) {

package/src/fileRepository/api/uploadVideo.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { rebuildFormDataWithMimeType } from '../utils/rebuildFormDataWithMimeType';
 
 /* begin_public_function
   id: file.upload.video, file.upload.audio
@@ -44,7 +43,7 @@ export const uploadVideo = async (
 
   const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
     '/api/v4/videos',
-    rebuildFormDataWithMimeType(formData),
+    formData,
     {
       headers,
       onUploadProgress({ loaded, total = 100 }) {

package/src/marker/events/onChannelUnreadUpdatedLocal.ts

@@ -0,0 +1,29 @@
+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,
+    'channelMarker/onChannelUnreadUpdatedLocal',
+    'local.channelUnread.updated',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerFetched.ts

@@ -22,7 +22,7 @@ export const onSubChannelMarkerFetched = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['local.subChannelMarker.fetched']) => {
-    callback(payload.userFeedMarkers[0]);
+    payload.userFeedMarkers.forEach(callback);
   };
 
   return createEventSubscriber(

package/src/marker/events/onSubChannelUnreadUpdatedLocal.ts

@@ -0,0 +1,29 @@
+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 onSubChannelUnreadUpdatedLocal = (
+  callback: Amity.Listener<Amity.Events['local.subChannelUnread.updated']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.subChannelUnread.updated']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'subChannelMarker/onSubChannelUnreadUpdatedLocal',
+    'local.subChannelUnread.updated',
+    filter,
+  );
+};

package/src/marker/events/onUserFeedMarkerUpdated.ts

@@ -23,10 +23,9 @@ export const onUserFeedMarkerUpdated = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.Events['marker.userFeed-updated']) => {
-    // update sub channel unread info and channel unread info in cache
-    persistUnreadCountInfo(payload);
-
-    callback(payload.feedMarkers[0]);
+    payload.feedMarkers.forEach(feedMarker => {
+      callback(feedMarker);
+    });
   };
 
   return createEventSubscriber(

package/src/marker/utils/reCalculateChannelUnreadInfo.ts

@@ -1,7 +1,7 @@
 import { pushToCache, queryCache } from '~/cache/api';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 
-export const reCalculateChannelUnreadInfo = async (channelId: string) => {
+export const reCalculateChannelUnreadInfo = (channelId: string): Amity.ChannelUnreadInfo => {
   const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
   const cacheChannelUnreadInfo =
     pullFromCache<Amity.ChannelUnreadInfo>(cacheKeyChannelUnread)?.data;
@@ -25,7 +25,7 @@ export const reCalculateChannelUnreadInfo = async (channelId: string) => {
     isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
   }
 
-  pushToCache(cacheKeyChannelUnread, {
+  const channelUnreadInfo = {
     ...(cacheChannelUnreadInfo ?? {
       channelId,
       createdAt: new Date().toISOString(),
@@ -33,5 +33,9 @@ export const reCalculateChannelUnreadInfo = async (channelId: string) => {
     updatedAt: new Date().toISOString(),
     unreadCount: channelUnreads,
     isMentioned,
-  });
+  };
+
+  pushToCache(cacheKeyChannelUnread, channelUnreadInfo);
+
+  return channelUnreadInfo;
 };

package/src/messagePreview/utils/getChannelMessagePreviewWithUser.ts

@@ -2,7 +2,11 @@ import { pullFromCache } from '~/cache/api';
 import { getChannelMessagePreview } from './getChannelMessagePreview';
 import { LinkedObject } from '~/utils/linkedObject';
 
-export const getChannelMessagePreviewWithUser = (channel: Amity.InternalChannel): Amity.Channel => {
+export const getChannelMessagePreviewWithUser = (
+  channel: Amity.InternalChannel,
+): Amity.InternalChannel & {
+  messagePreview: Amity.MessagePreview | null;
+} => {
   const messagePreview = channel.messagePreviewId
     ? getChannelMessagePreview(channel.channelId)
     : null;

package/src/messageRepository/events/onMessageCreated.ts

@@ -4,6 +4,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareMessagePayload } from '../utils';
 import { updateSubChannelUnreadFromMessage } from '~/marker/utils/updateSubChannelUnreadFromMessage';
 import { reCalculateChannelUnreadInfo } from '~/marker/utils/reCalculateChannelUnreadInfo';
+import { markReadMessage } from '../utils/markReadMessage';
+import { getActiveUser } from '~/client/api/activeUser';
 
 /**
  * ```js
@@ -25,6 +27,7 @@ export const onMessageCreatedMqtt = (
   callback: Amity.Listener<Amity.InternalMessage>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
+  const user = getActiveUser();
 
   const filter = async (rawPayload: Amity.MessagePayload) => {
     const payload = await prepareMessagePayload(rawPayload);
@@ -41,6 +44,7 @@ export const onMessageCreatedMqtt = (
     ingestInCache(payload);
 
     payload.messages.forEach(message => {
+      if (message.creatorPrivateId === user._id) markReadMessage(message);
       callback(message);
     });
   };

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -49,7 +49,7 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     );
 
     this.callback = callback.bind(this);
-    this.loadPage(true);
+    this.loadPage({ initial: true });
   }
 
   protected setup() {
@@ -107,8 +107,8 @@ export class MessageLiveCollectionController extends LiveCollectionController<
     if (!this.shouldNotify(data) && origin === 'event') return;
 
     this.callback({
-      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
-      onPrevPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.PREV),
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      onPrevPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.PREV }),
       data,
       hasNextPage: !!this.paginationController.getNextToken(),
       hasPrevPage: !!this.paginationController.getPrevToken(),