@amityco/ts-sdk-react-native 6.29.2 → 6.29.3-fe4e045.0

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersLiveCollectionController.ts

@@ -16,6 +16,8 @@ import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
 import { prepareCommunityPayload } from '~/communityRepository/utils';
 import { isNonNullable } from '~/utils';
 import { EnumCommunityMemberActions } from './enums';
+import { onLocalCommunityRoleRemoved } from '~/communityRepository/communityModeration/events/onLocalCommunityRoleRemoved';
+import { onUserDeleted } from '~/communityRepository/communityMembership/events/onUserDeleted';
 
 export class SearchCommunityMembersLiveCollectionController extends LiveCollectionController<
   'communityUser',
@@ -79,11 +81,19 @@ export class SearchCommunityMembersLiveCollectionController extends LiveCollecti
       { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
       { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
       { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
+      {
+        fn: onLocalCommunityRoleRemoved,
+        action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
+      },
       {
         fn: onCommunityUserRoleRemoved,
         action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
       },
       { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions.OnCommunityUserUnbanned },
+      {
+        fn: onUserDeleted(this.query.communityId),
+        action: EnumCommunityMemberActions.OnCommunityUserChanged,
+      },
     ]);
   }
 
@@ -125,6 +135,10 @@ export class SearchCommunityMembersLiveCollectionController extends LiveCollecti
       communityMembers = filterBySearchTerm(communityMembers, this.query.search);
     }
 
+    if (this.query.includeDeleted === false) {
+      communityMembers = communityMembers.filter(({ user }) => user?.isDeleted !== true);
+    }
+
     return communityMembers;
   }
 }

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersPaginationController.ts

@@ -13,15 +13,18 @@ export class SearchCommunityMembersPaginationController extends PaginationContro
     queryParams: Amity.SearchCommunityMemberLiveCollection,
     token: string | undefined,
   ) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
     const options = token ? { token } : { limit };
 
+    const isDeleted = includeDeleted === false ? false : undefined;
+
     const { data: queryResponse } = await this.http.get<
       Amity.CommunityMembershipPayload & Amity.Pagination
     >(`/api/v3/communities/${params.communityId}/users`, {
       params: {
         ...params,
         options,
+        isDeleted,
       },
     });
     return queryResponse;

package/src/communityRepository/communityModeration/api/addRoles.ts

@@ -1,7 +1,8 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMembershipPayload } from '~/group/utils';
+import { fireEvent } from '~/core/events';
+import { prepareCommunityMembershipPayload } from '~/communityRepository/utils';
 
 /* begin_public_function
   id: community.moderation.add_roles
@@ -35,10 +36,12 @@ export const addRoles = async (
     { communityId, roles: roleIds, userIds },
   );
 
-  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const data = prepareCommunityMembershipPayload(payload);
 
   if (client.cache) ingestInCache(data);
 
+  fireEvent('local.community.roleAdded', data);
+
   const { communityUsers } = data;
   return !!communityUsers.find(
     communityUser =>

package/src/communityRepository/communityModeration/api/removeRoles.ts

@@ -1,7 +1,8 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMembershipPayload } from '~/group/utils';
+import { prepareCommunityMembershipPayload } from '~/communityRepository/utils';
+import { fireEvent } from '~/core/events';
 
 /* begin_public_function
   id: community.moderation.remove_roles
@@ -35,10 +36,12 @@ export const removeRoles = async (
     { data: { communityId, roles: roleIds, userIds } },
   );
 
-  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const data = prepareCommunityMembershipPayload(payload);
 
   if (client.cache) ingestInCache(data);
 
+  fireEvent('local.community.roleRemoved', data);
+
   const { communityUsers } = data;
   return !!communityUsers.find(
     communityUser =>

package/src/communityRepository/communityModeration/events/onLocalCommunityRoleAdded.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onLocalCommunityRoleAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityRoleAdded((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.communityUsers} 's role has been added to any {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onLocalCommunityRoleAdded = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (payload: Amity.ProcessedCommunityMembershipPayload) => {
+    const { communities, communityUsers } = payload;
+    callback(
+      communities[0],
+      communityUsers.filter(communityUser => communityUser.communityMembership === 'member')!,
+    );
+  };
+
+  return createEventSubscriber(
+    client,
+    'onLocalCommunityRoleAdded',
+    'local.community.roleAdded',
+    filter,
+  );
+};

package/src/communityRepository/communityModeration/events/onLocalCommunityRoleRemoved.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onLocalCommunityRoleRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityRoleRemoved((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.communityUsers} 's role has been added to any {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onLocalCommunityRoleRemoved = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (payload: Amity.ProcessedCommunityMembershipPayload) => {
+    const { communities, communityUsers } = payload;
+    callback(
+      communities[0],
+      communityUsers.filter(communityUser => communityUser.communityMembership === 'member')!,
+    );
+  };
+
+  return createEventSubscriber(
+    client,
+    'onLocalCommunityRoleRemoved',
+    'local.community.roleRemoved',
+    filter,
+  );
+};

package/src/communityRepository/utils/payload.ts

@@ -1,6 +1,4 @@
 import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
-import { pullFromCache } from '~/cache/api';
-import { withUsers } from '~/group/utils';
 import { updateMembershipStatus } from './communityWithMembership';
 
 const getMatchPostSetting = (value: {
@@ -14,31 +12,8 @@ const getMatchPostSetting = (value: {
       value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
   ) ?? DefaultCommunityPostSetting;
 
-const convertCommunityUsersToUniqueObject = (
-  communityUsers: Amity.RawMembership<'community'>[],
-) => {
-  if (!communityUsers) return communityUsers;
-
-  const result: {
-    [key: string]: Amity.RawMembership<'community'>;
-  } = {};
-
-  communityUsers.forEach(user => {
-    result[`${user.userId}#${user.communityId}`] = user;
-  });
-
-  return result;
-};
-
-export const convertCommunityPayload = (rawPayload: {
-  communities: Amity.RawCommunity[];
-  communityUsers: Amity.RawMembership<'community'>[];
-}): {
-  communities: Amity.Community[];
-  communityUsers: Amity.Membership<'community'>[];
-} => {
-  // Unpack community payload by mapping payload field to postSetting value.
-  const communities = rawPayload.communities.map<Amity.Community>(
+export function addPostSetting({ communities }: { communities: Amity.RawCommunity[] }) {
+  return communities.map<Amity.Community>(
     ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
       postSetting: getMatchPostSetting({
         needApprovalOnPostCreation,
@@ -47,44 +22,63 @@ export const convertCommunityPayload = (rawPayload: {
       ...restCommunityPayload,
     }),
   );
+}
 
-  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));
+export const prepareCommunityPayload = (
+  rawPayload: Amity.CommunityPayload,
+): Amity.ProcessedCommunityPayload => {
+  const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = rawPayload.communityUsers.map(
+    communityUser => {
+      const user = rawPayload.users.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
 
-  const communityWithMembershipStatus = updateMembershipStatus(communities, communityUsers);
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
 
   return {
     ...rawPayload,
     communities: communityWithMembershipStatus,
-    communityUsers,
+    communityUsers: mappedCommunityUsers,
   };
 };
 
-export const prepareCommunityPayload = (
-  rawPayload: Amity.CommunityPayload,
-): Amity.ProcessedCommunityPayload => {
-  const { communities, communityUsers } = convertCommunityPayload(rawPayload);
+export const prepareCommunityMembershipPayload = (
+  rawPayload: Amity.CommunityMembershipPayload,
+): Amity.ProcessedCommunityMembershipPayload => {
+  const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = rawPayload.communityUsers.map(
+    communityUser => {
+      const user = rawPayload.users.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
+
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
 
   return {
     ...rawPayload,
-    communities,
-    communityUsers,
+    communities: communityWithMembershipStatus,
+    communityUsers: mappedCommunityUsers,
   };
 };
 

package/src/core/model/idResolvers.ts

@@ -56,6 +56,9 @@ const idResolvers: Resolvers = {
 
   ad: ({ adId }) => adId,
   advertiser: ({ advertiserId }) => advertiserId,
+
+  pin: ({ referenceId }) => referenceId,
+  pinTarget: ({ targetId }) => targetId,
 };
 
 /**

package/src/core/model/index.ts

@@ -49,6 +49,9 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   feeds: 'feed',
   ads: 'ad',
   advertisers: 'advertiser',
+
+  pinTargets: 'pinTarget',
+  pins: 'pin',
 };
 
 /** hidden */

package/src/group/utils/withUser.ts

@@ -1,6 +1,39 @@
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getActiveClient } from '~/client/api/activeClient';
 
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+export const convertRawMembershipToMembership = <T extends Amity.GroupType>(
+  member: Amity.RawMembership<T>,
+): Amity.Membership<T> => {
+  return {
+    ...member,
+    get user() {
+      const client = getActiveClient();
+
+      if (!client.cache) return undefined;
+
+      const userCache = pullFromCache<Amity.InternalUser>(['user', 'get', member.userId])?.data;
+
+      if (!userCache) {
+        return undefined;
+      }
+
+      return userCache;
+    },
+  };
+};
+
 /**
  * Attach user object to membership model
  * - If cache is not enabled, set user to undefined ({..., user: undefined})

package/src/postRepository/api/deletePost.ts

@@ -71,7 +71,15 @@ export const deletePost = async (
   // to support hard deletion
   const deleted = { ...post.data, isDeleted: true };
 
-  fireEvent('post.deleted', {
+  if (permanent) {
+    setTimeout(() => {
+      pushToTombstone('post', postId);
+    }, 0);
+  } else {
+    upsertInCache(['post', 'get', postId], { isDeleted: true });
+  }
+
+  fireEvent('local.post.deleted', {
     posts: [deleted],
     categories: [],
     comments: [],
@@ -83,13 +91,5 @@ export const deletePost = async (
     users: [],
   });
 
-  if (permanent) {
-    setTimeout(() => {
-      pushToTombstone('post', postId);
-    }, 0);
-  } else {
-    upsertInCache(['post', 'get', postId], { isDeleted: true });
-  }
-
   return LinkedObject.post(deleted);
 };

package/src/postRepository/api/updatePost.ts

@@ -51,7 +51,7 @@ export const updatePost = async <T extends Amity.PostContentType>(
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('local.post.updated', data);
+  fireEvent('local.post.updated', payload);
 
   const { posts } = data;
 

package/src/postRepository/events/onLocalPostDeleted.ts

@@ -0,0 +1,20 @@
+import { createLocalPostEventSubscriber, createPostEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onLocalPostDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onLocalPostDeleted = (
+  callback: Amity.Listener<Amity.InternalPost>,
+): Amity.Unsubscriber => createLocalPostEventSubscriber('local.post.deleted', callback);

package/src/postRepository/events/onLocalPostReactionAdded.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePostPayload } from '../utils/payload';
+
+/**
+ * ```js
+ * import { onLocalPostReactionAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onLocalPostReactionAdded = (
+  callback: Amity.Listener<Amity.InternalPost>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = ({ post }: Amity.Events['local.post.addReaction']) => {
+    if (!client.cache) {
+      callback(post);
+    } else {
+      upsertInCache(['post', 'get', post.postId], post);
+
+      callback(post);
+    }
+  };
+
+  return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+};

package/src/postRepository/events/onLocalPostReactionRemoved.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onLocalPostReactionRemoved = (
+  callback: Amity.Listener<Amity.InternalPost>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = ({ post }: Amity.Events['local.post.removeReaction']) => {
+    if (!client.cache) {
+      callback(post);
+    } else {
+      upsertInCache(['post', 'get', post.postId], post);
+
+      callback(post);
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.post.removeReaction',
+    'local.post.removeReaction',
+    filter,
+  );
+};

package/src/postRepository/events/onPostUpdatedLocal.ts

@@ -0,0 +1,20 @@
+import { createLocalPostEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onPostUpdatedLocal } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPostUpdatedLocal(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostUpdatedLocal = (
+  callback: Amity.Listener<Amity.InternalPost>,
+): Amity.Unsubscriber => createLocalPostEventSubscriber('local.post.updated', callback);

package/src/postRepository/events/utils.ts

@@ -1,10 +1,9 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber, fireEvent } from '~/core/events';
-import { pullFromCache, queryCache, upsertInCache } from '~/cache/api';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { prepareMembershipPayload } from '~/group/utils';
+import { dropFromCache, pullFromCache, queryCache, upsertInCache } from '~/cache/api';
 import { isInTombstone } from '~/cache/api/isInTombstone';
+import { preparePostPayload } from '~/postRepository/utils/payload';
 
 export const createPostEventSubscriber = (
   event: keyof Amity.MqttPostEvents,
@@ -16,9 +15,9 @@ export const createPostEventSubscriber = (
     if (!client.cache) {
       callback(payload.posts[0]);
     } else {
-      const { communities, ...others } = payload;
+      const data = preparePostPayload(payload);
 
-      const data = prepareMembershipPayload(others, 'communityUsers');
+      const { communities } = data;
 
       ingestInCache(data);
 
@@ -49,7 +48,7 @@ export const createPostEventSubscriber = (
         // But if it is hard delete, it will pushed into tombstone before fire an event to BE. it means it will stay in tombstone already
         // and will got skip to notify in a previous code block
         if (postedUserId !== client.userId) {
-          pushToTombstone('post', postId);
+          dropFromCache(['post', 'get', postId]);
         }
 
         return callback(payload.posts[0]);
@@ -76,3 +75,39 @@ export const createPostEventSubscriber = (
 
   return createEventSubscriber(client, event, event, filter);
 };
+
+export const createLocalPostEventSubscriber = (
+  event: keyof Omit<Amity.LocalPostEvents, 'local.post.addReaction' | 'local.post.removeReaction'>,
+  callback: Amity.Listener<Amity.InternalPost>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.PostPayload) => {
+    if (!client.cache) {
+      callback(payload.posts[0]);
+    } else {
+      const data = preparePostPayload(payload);
+
+      const { communities } = data;
+
+      ingestInCache(data);
+
+      if (communities?.[0] && !['local.post.updated'].includes(event)) {
+        fireEvent('community.updated', {
+          communities,
+          categories: [],
+          communityUsers: data.communityUsers,
+          feeds: [],
+          files: [],
+          users: [],
+        });
+      }
+
+      const post = pullFromCache<Amity.InternalPost>(['post', 'get', payload.posts[0].postId])!;
+
+      callback(post.data);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/postRepository/internalApi/index.ts

@@ -1,16 +1 @@
-export * from './getPostByIds';
-
-export * from './createPost';
-export * from './updatePost';
-export * from './editPost';
-
-export * from './deletePost';
-export * from './softDeletePost';
-export * from './hardDeletePost';
-
-export * from './approvePost';
-export * from './declinePost';
-
-export * from './flagPost';
-export * from './unflagPost';
-export * from './isPostFlaggedByMe';
+export * from './getPost';