@amityco/ts-sdk-react-native 6.24.0 → 6.24.1

package/dist/utils/liveObject.d.ts

@@ -1,2 +1,5 @@
+/**
+ * @deprecated This function is deprecated
+ */
 export declare const liveObject: <T extends Amity.Model, K extends keyof T, CallbackData extends unknown = any>(id: T[K], callback: Amity.LiveObjectCallback<CallbackData>, key: K, fetcher: (id: T[K]) => Promise<Amity.Cached<T>>, eventHandlers: ((callback: Amity.Listener<T>) => Amity.Unsubscriber)[], options?: Amity.LiveObjectOptions<T, CallbackData> | undefined) => Amity.Unsubscriber;
 //# sourceMappingURL=liveObject.d.ts.map

package/dist/utils/liveObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"liveObject.d.ts","sourceRoot":"","sources":["../../src/utils/liveObject.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,UAAU,uPASiC,MAAM,YAAY,wEAEvE,MAAM,YAmFR,CAAC"}
+{"version":3,"file":"liveObject.d.ts","sourceRoot":"","sources":["../../src/utils/liveObject.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,eAAO,MAAM,UAAU,uPASiC,MAAM,YAAY,wEAEvE,MAAM,YAmFR,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.24.0",
+  "version": "6.24.1",
   "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/community.ts

@@ -121,7 +121,22 @@ declare global {
       communityId: string;
       memberships?: ('banned' | 'member')[];
       roles?: string[];
-      sortBy?: 'firstCreated' | 'lastCreated';
+      sortBy?:
+        | 'firstCreated'
+        | 'lastCreated'
+        /** @deprecated sortBy displayName is not available */
+        | 'displayName';
+      /** @deprecated use searchCommunityMembers instead */
+      search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
+      page?: string;
+      limit?: number;
+    };
+
+    type QuerySearchCommunityMembers = {
+      communityId: string;
+      memberships?: ('banned' | 'member')[];
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated' | 'displayName';
       search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
       page?: string;
       limit?: number;
@@ -131,9 +146,18 @@ declare global {
       Omit<QueryCommunityMembers, 'page'>
     >;
 
+    type SearchCommunityMemberLiveCollection = Amity.LiveCollectionParams<
+      Omit<QuerySearchCommunityMembers, 'page'>
+    >;
+
     type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
       Amity.Membership<'community'>['userId'],
       Pick<QueryCommunityMembers, 'page'>
     >;
+
+    type SearchCommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<QuerySearchCommunityMembers, 'page'>
+    >;
   }
 }

package/src/client/api/secureLogout.ts

@@ -6,7 +6,7 @@ import { logout } from './logout';
 */
 /**
  * ```js
- * import { Client } from '@amityco/ts-sdk'
+ * import { Client } from '@amityco/ts-sdk-react-native'
  * const success = await Client.secureLogout()
  * ```
  *

package/src/client/utils/markerSyncEngine.ts

@@ -18,6 +18,7 @@ import { enableUnreadCount } from '../api/enableUnreadCount';
 
 import { onOnline } from './onOnline';
 import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { getActiveClient } from '~/client/api/activeClient';
 
 const SYNC_TRIGGER_INTERVAL_TIME = 2000;
 const ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY = 2000;
@@ -145,7 +146,9 @@ const registerEventListeners = () => {
 
     onMessageCreatedMqtt(message => {
       // only conversation, community and broadcast types can sync
-      if (isUnreadCountSupport(message)) events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
+      const client = getActiveClient();
+      if (isUnreadCountSupport(message) && message.creatorId !== client.userId)
+        events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
     }),
 
     onChannelCreated(() => events.push(Amity.MarkerSyncEvent.CHANNEL_CREATED)),

package/src/commentRepository/events/utils.ts

@@ -39,11 +39,14 @@ export const createCommentEventSubscriber = (
             ]);
 
             if (parentComment?.data) {
-              pushToCache(['comment', 'get', comments[0].parentId], {
-                ...parentComment.data,
-                childrenNumber: parentComment.data.childrenNumber + 1,
-                children: [...new Set([...parentComment.data.children, comments[0].commentId])],
-              });
+              // Skip to update parent childComment if current comment already exists
+              if (!parentComment.data.children.includes(comments[0].commentId)) {
+                pushToCache(['comment', 'get', comments[0].parentId], {
+                  ...parentComment.data,
+                  childrenNumber: parentComment.data.childrenNumber + 1,
+                  children: [...new Set([...parentComment.data.children, comments[0].commentId])],
+                });
+              }
             }
           }
 

package/src/communityRepository/api/createCommunity.ts

@@ -2,7 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
-
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload, prepareCommunityRequest } from '../utils';
 
 /* begin_public_function
@@ -53,7 +53,10 @@ export const createCommunity = async (
   const data = prepareCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+    saveCommunityUsers(data.communities, data.communityUsers);
+  }
 
   const { communities } = data;
   return {

package/src/communityRepository/api/getCommunities.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
 
 /**
@@ -36,7 +37,10 @@ export const getCommunities = async (
   const data = prepareCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+    saveCommunityUsers(data.communities, data.communityUsers);
+  }
 
   return {
     data: data.communities,

package/src/communityRepository/api/getCommunity.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
 
 /**
@@ -33,7 +34,10 @@ export const getCommunity = async (
   const data = prepareCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+    saveCommunityUsers(data.communities, data.communityUsers);
+  }
 
   const { communities } = data;
 

package/src/communityRepository/api/queryCommunities.ts

@@ -1,11 +1,10 @@
 import { getActiveClient } from '~/client/api';
-
-import { toPage, toToken } from '~/core/query';
 import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
 
 /**
@@ -67,6 +66,7 @@ export const queryCommunities = async (
 
     const cacheKey = ['community', 'query', { ...params, options } as Amity.Serializable];
     pushToCache(cacheKey, { communities: communities.map(getResolver('community')), paging });
+    saveCommunityUsers(data.communities, data.communityUsers);
   }
 
   return { data: communities, cachedAt, paging };

package/src/communityRepository/api/updateCommunity.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload, prepareCommunityRequest } from '../utils';
 
 /* begin_public_function
@@ -44,7 +45,10 @@ export const updateCommunity = async (
   const data = prepareCommunityPayload(payload);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+    saveCommunityUsers(data.communities, data.communityUsers);
+  }
 
   const { communities } = data;
 

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersLiveCollectionController.ts

@@ -0,0 +1,151 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CommunityMembersPaginationController } from './CommunityMembersPaginationController';
+import { CommunityMembersQueryStreamController } from './CommunityMembersQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserBanned,
+  onCommunityUserChanged,
+  onCommunityUserRoleAdded,
+  onCommunityUserRoleRemoved,
+  onCommunityUserUnbanned,
+} from '~/communityRepository/communityMembership/events';
+import {
+  filterByPropIntersection,
+  filterBySearchTerm,
+  sortByDisplayName,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+import { isNonNullable } from '~/utils';
+import { EnumCommunityMemberActions } from './enums';
+
+export class CommunityMembersLiveCollectionController extends LiveCollectionController<
+  'communityUser',
+  Amity.CommunityMemberLiveCollection,
+  Amity.Membership<'community'>,
+  CommunityMembersPaginationController
+> {
+  private queryStreamController: CommunityMembersQueryStreamController;
+
+  private query: Amity.CommunityMemberLiveCollection;
+
+  constructor(
+    query: Amity.CommunityMemberLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Membership<'community'>>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['communityUsers', 'collection', queryStreamId];
+    const paginationController = new CommunityMembersPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CommunityMembersQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommunityMembershipPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'communityUser'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
+      { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
+      { fn: onCommunityUserRoleAdded, action: EnumCommunityMemberActions.OnCommunityUserRoleAdded },
+      {
+        fn: onCommunityUserRoleRemoved,
+        action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
+      },
+      { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions.OnCommunityUserUnbanned },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Membership<'community'>>(['communityUsers', 'get', id])!)
+        .filter(isNonNullable)
+        .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.Membership<'community'>[]) {
+    let communityMembers = filterByPropIntersection(data, 'roles', this.query.roles);
+
+    if (this.query.memberships) {
+      communityMembers = communityMembers.filter(({ communityMembership }) => {
+        const memberships: Amity.GroupMembership[] = this.query.memberships || [];
+        return memberships.includes(communityMembership);
+      });
+    }
+
+    if (this.query.search) {
+      communityMembers = filterBySearchTerm(communityMembers, this.query.search);
+    }
+
+    switch (this.query.sortBy) {
+      case 'firstCreated':
+        communityMembers = communityMembers.sort(sortByFirstCreated);
+        break;
+      case 'displayName':
+        communityMembers = communityMembers.sort((a, b) => {
+          if (a?.user?.displayName && b?.user?.displayName) {
+            return a?.user?.displayName.localeCompare(b?.user?.displayName);
+          }
+          return 0;
+        });
+        break;
+      case 'lastCreated':
+      default:
+        communityMembers = communityMembers.sort(sortByLastCreated);
+        break;
+    }
+
+    return communityMembers;
+  }
+}

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersPaginationController.ts

@@ -0,0 +1,26 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class CommunityMembersPaginationController extends PaginationController<
+  'communityUser',
+  Amity.CommunityMemberLiveCollection
+> {
+  async getRequest(queryParams: Amity.CommunityMemberLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.CommunityMembershipPayload & Amity.Pagination
+    >(`/api/v3/communities/${params.communityId}/users`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersQueryStreamController.ts

@@ -0,0 +1,114 @@
+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 { EnumCommunityMemberActions } from './enums';
+
+export class CommunityMembersQueryStreamController extends QueryStreamController<
+  Amity.CommunityMembershipPayload,
+  Amity.CommunityMemberLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.CommunityMembershipPayload,
+  ) => Amity.ProcessedCommunityMembershipPayload;
+
+  constructor(
+    query: Amity.CommunityMemberLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.CommunityMembershipPayload,
+    ) => Amity.ProcessedCommunityMembershipPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommunityMembershipPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommunityMembershipPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.communityUsers.map(({ communityId, userId }) =>
+          getResolver('communityUsers')({ communityId, userId }),
+        ),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const communityUsers = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...communityUsers,
+            ...response.communityUsers.map(({ communityId, userId }) =>
+              getResolver('communityUsers')({ communityId, userId }),
+            ),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: EnumCommunityMemberActions) {
+    return (community: Amity.Community, communityMembers: Amity.Membership<'community'>[]) => {
+      const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      if (
+        action === EnumCommunityMemberActions.OnCommunityUserRoleAdded &&
+        this.query.sortBy === 'displayName'
+      ) {
+        return;
+      }
+
+      communityMembers.forEach(communityMember => {
+        const communityMemberCacheId = getResolver('communityUsers')({
+          communityId: this.query.communityId,
+          userId: communityMember.userId,
+        });
+
+        if (communityMember.communityMembership === 'none') {
+          collection.data = collection.data.filter(m => m !== communityMemberCacheId);
+        } else if (!collection.data.includes(communityMemberCacheId)) {
+          collection.data = [communityMemberCacheId, ...collection.data];
+        }
+      });
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (
+        reactor: (channel: Amity.Community, communityUser: Amity.Membership<'community'>[]) => void,
+      ) => Amity.Unsubscriber;
+      action: EnumCommunityMemberActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/communityRepository/communityMembership/observers/getMembers/enums.ts

@@ -0,0 +1,10 @@
+export enum EnumCommunityMemberActions {
+  OnCommunityJoined = 'onCommunityJoined',
+  OnCommunityLeft = 'onCommunityLeft',
+  OnCommunityUserBanned = 'onCommunityUserBanned',
+  OnCommunityUserChanged = 'onCommunityUserChanged',
+  OnCommunityUserRoleAdded = 'onCommunityUserRoleAdded',
+  OnCommunityUserRoleRemoved = 'onCommunityUserRoleRemoved',
+  OnCommunityUserUnbanned = 'onCommunityUserUnbanned',
+  OnMemberCountChanged = 'OnMemberCountChanged',
+}