@amityco/ts-sdk-react-native 7.5.3 → 7.6.0

package/src/invitationRepository/observers/getMyInvitations/MyInvitationsLiveCollectionController.ts

@@ -0,0 +1,148 @@
+import hash from 'object-hash';
+import { isNonNullable } from '~/utils';
+import { invitationLinkedObject } from '~/utils/linkedObject/invitationLinkedObject';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { MyInvitationsPaginationController } from './MyInvitationsPaginationController';
+import { MyInvitationsQueryStreamController } from './MyInvitationsQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onLocalInvitationCreated,
+  onLocalInvitationDeleted,
+  onLocalInvitationUpdated,
+} from '~/invitationRepository/events';
+import { prepareMyInvitationsPayload } from '~/invitationRepository/utils/prepareMyInvitationsPayload';
+import { InvitationActionsEnum } from '../getInvitations/enums';
+
+export class MyInvitationsLiveCollectionController extends LiveCollectionController<
+  'myInvitation',
+  Amity.MyInvitationsLiveCollection,
+  Amity.Invitation,
+  MyInvitationsPaginationController
+> {
+  private queryStreamController: MyInvitationsQueryStreamController;
+
+  private query: Amity.MyInvitationsLiveCollection;
+
+  constructor(
+    query: Amity.MyInvitationsLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['invitation', 'collection', queryStreamId];
+    const paginationController = new MyInvitationsPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new MyInvitationsQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareMyInvitationsPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.MyInvitationsLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: this.query,
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.MyInvitationsPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'myInvitation'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      {
+        fn: onLocalInvitationCreated,
+        action: InvitationActionsEnum.OnLocalInvitationCreated,
+      },
+      {
+        fn: onLocalInvitationUpdated,
+        action: InvitationActionsEnum.OnLocalInvitationUpdated,
+      },
+      {
+        fn: onLocalInvitationDeleted,
+        action: InvitationActionsEnum.OnLocalInvitationDeleted,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.MyInvitationsLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalInvitation>(['invitation', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => invitationLinkedObject(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.Invitation[]) {
+    let invitations = data;
+
+    if (this.query.targetId) {
+      invitations = invitations.filter(invitation => invitation.targetId === this.query.targetId);
+    }
+
+    if (this.query.statuses) {
+      invitations = invitations.filter(invitation =>
+        this.query.statuses?.includes(invitation.status),
+      );
+    }
+
+    if (this.query.targetType) {
+      invitations = invitations.filter(
+        invitation => invitation.targetType === this.query.targetType,
+      );
+    }
+
+    if (this.query.type) {
+      invitations = invitations.filter(invitation => invitation.type === this.query.type);
+    }
+
+    const sortFn = (() => {
+      switch (this.query.sortBy) {
+        case 'firstCreated':
+          return sortByFirstCreated;
+        case 'lastCreated':
+          return sortByLastCreated;
+        default:
+          return sortByLastCreated;
+      }
+    })();
+
+    invitations = invitations.sort(sortFn);
+
+    return invitations;
+  }
+}

package/src/invitationRepository/observers/getMyInvitations/MyInvitationsPaginationController.ts

@@ -0,0 +1,22 @@
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { getCommunityByIds } from '~/communityRepository';
+
+export class MyInvitationsPaginationController extends PaginationController<
+  'myInvitation',
+  Amity.MyInvitationsLiveCollection
+> {
+  async getRequest(queryParams: Amity.MyInvitationsLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data } = await this.http.get<Amity.MyInvitationsPayload & Amity.Pagination>(
+      '/api/v1/invitations/me',
+      { params: { ...params, options } },
+    );
+
+    await getCommunityByIds(data.invitations.map(invitation => invitation.communityId));
+
+    return data;
+  }
+}

package/src/invitationRepository/observers/getMyInvitations/MyInvitationsQueryStreamController.ts

@@ -0,0 +1,105 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { InvitationActionsEnum } from '../getInvitations/enums';
+
+export class MyInvitationsQueryStreamController extends QueryStreamController<
+  Amity.MyInvitationsPayload,
+  Amity.MyInvitationsLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.MyInvitationsPayload,
+  ) => Amity.ProcessedMyInvitationsPayload;
+
+  constructor(
+    query: Amity.MyInvitationsLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.MyInvitationsPayload) => Amity.ProcessedMyInvitationsPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.MyInvitationsPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.MyInvitationsPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.invitations.map(getResolver('invitation')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.MyInvitationsLiveCollectionCache>(this.cacheKey)?.data;
+
+      const invitations = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([...invitations, ...response.invitations.map(getResolver('invitation'))]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: InvitationActionsEnum) {
+    return (invitations: Amity.InternalInvitation[]) => {
+      const collection = pullFromCache<Amity.InvitationLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (action === InvitationActionsEnum.OnLocalInvitationUpdated) {
+        const isExist = collection.data.find(id => id === invitations[0].invitationId);
+        if (!isExist) return;
+      }
+
+      if (action === InvitationActionsEnum.OnLocalInvitationCreated) {
+        const client = getActiveClient();
+
+        const myInvitations = invitations.filter(
+          invitation => invitation.invitedUserId === client.userId,
+        );
+
+        collection.data = [
+          ...new Set([
+            ...myInvitations.map(invitation => invitation.invitationId),
+            ...collection.data,
+          ]),
+        ];
+      }
+
+      if (action === InvitationActionsEnum.OnLocalInvitationDeleted) {
+        collection.data = collection.data.filter(id => id !== invitations[0].invitationId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalInvitation[]>) => Amity.Unsubscriber;
+      action: InvitationActionsEnum;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/invitationRepository/observers/index.ts

@@ -0,0 +1 @@
+export * from './getMyCommunityInvitations';

package/src/invitationRepository/utils/convertRawInvitationToInternalInvitation.ts

@@ -0,0 +1,8 @@
+export const convertRawInvitationToInternalInvitation = (
+  rawInvitation: Amity.RawInvitation,
+): Amity.InternalInvitation => {
+  return {
+    ...rawInvitation,
+    createdById: rawInvitation.createdBy,
+  };
+};

package/src/invitationRepository/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareInvitationPayload';

package/src/invitationRepository/utils/prepareInvitationPayload.ts

@@ -0,0 +1,12 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+import { convertRawInvitationToInternalInvitation } from './convertRawInvitationToInternalInvitation';
+
+export const prepareInvitationPayload = (
+  rawPayload: Amity.InvitationPayload,
+): Amity.ProcessedInvitationPayload => {
+  return {
+    ...rawPayload,
+    invitations: rawPayload.invitations.map(convertRawInvitationToInternalInvitation),
+    users: rawPayload.users.map(convertRawUserToInternalUser),
+  };
+};

package/src/invitationRepository/utils/prepareMyInvitationsPayload.ts

@@ -0,0 +1,12 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+import { convertRawInvitationToInternalInvitation } from './convertRawInvitationToInternalInvitation';
+
+export const prepareMyInvitationsPayload = (
+  rawPayload: Amity.MyInvitationsPayload,
+): Amity.ProcessedMyInvitationsPayload => {
+  return {
+    ...rawPayload,
+    users: rawPayload.users.map(convertRawUserToInternalUser),
+    invitations: rawPayload.invitations.map(convertRawInvitationToInternalInvitation),
+  };
+};

package/src/messagePreview/utils/getChannelMessagePreviewWithUser.ts

@@ -1,6 +1,6 @@
-import { pullFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getChannelMessagePreview } from './getChannelMessagePreview';
-import { LinkedObject } from '~/utils/linkedObject';
+import { userLinkedObject } from '~/utils/linkedObject/userLinkedObject';
 
 export const getChannelMessagePreviewWithUser = (
   channel: Amity.StaticInternalChannel,
@@ -20,7 +20,7 @@ export const getChannelMessagePreviewWithUser = (
   const messagePreviewWithUser = messagePreview
     ? {
         ...messagePreview,
-        user: internalUser ? LinkedObject.user(internalUser) : undefined,
+        user: internalUser ? userLinkedObject(internalUser) : undefined,
       }
     : null;
 

package/src/postRepository/observers/getGlobalPinnedPosts/GlobalPinnedPostQueryStreamController.ts

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client';
 import { EnumPostActions } from '../enums';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export class GlobalPinnedPostQueryStreamController extends QueryStreamController<
   Amity.PinnedPostPayload,
@@ -30,7 +31,12 @@ export class GlobalPinnedPostQueryStreamController extends QueryStreamController
     const cachedAt = client.cache && Date.now();
 
     if (client.cache) {
-      ingestInCache(response, { cachedAt });
+      const processedPayload = {
+        ...response,
+        users: response.users.map(convertRawUserToInternalUser),
+      };
+
+      ingestInCache(processedPayload, { cachedAt });
     }
   }
 

package/src/postRepository/observers/getPinnedPosts/PinnedPostQueryStreamController.ts

@@ -3,6 +3,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export class PinnedPostQueryStreamController extends QueryStreamController<
   Amity.PinnedPostPayload,
@@ -29,7 +30,12 @@ export class PinnedPostQueryStreamController extends QueryStreamController<
     const cachedAt = client.cache && Date.now();
 
     if (client.cache) {
-      ingestInCache(response, { cachedAt });
+      const processedPayload = {
+        ...response,
+        users: response.users ? response.users.map(convertRawUserToInternalUser) : [],
+      };
+
+      ingestInCache(processedPayload, { cachedAt });
     }
   }
 

package/src/subChannelRepository/utils/prepareSubChannelPayload.ts

@@ -4,6 +4,7 @@ import { convertFromRaw as convertMessageFromRaw } from '~/messageRepository/uti
 import { convertFromRaw as convertSubChannelFromRaw } from './convertSubChannelFromRaw';
 
 import { updateSubChannelMessagePreviewCache } from '../../messagePreview/utils/updateSubChannelMessagePreviewCache';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 
@@ -44,10 +45,13 @@ export const prepareSubChannelPayload = async (
 
   const messages = rawPayload.messages.map(m => convertMessageFromRaw(m));
 
+  const user = rawPayload.users.map(convertRawUserToInternalUser);
+
   return {
     ...rawPayload,
     messageFeeds,
     messages,
+    users: user,
   };
 };
 

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -1,8 +1,27 @@
 import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
 import { shallowClone } from '../shallowClone';
+import { queryCache } from '~/cache/api';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
+  let previewMembers: Amity.Membership<'channel'>[] = [];
+
+  if (channel.type === 'conversation') {
+    const channelUsers = queryCache<Amity.Membership<'channel'>>(['channelUsers', 'get']);
+    if (channelUsers && channelUsers?.length > 0) {
+      previewMembers = (
+        channelUsers?.filter(({ data }) => data.channelId === channel.channelId) ?? []
+      )
+        // sort in ascending order by userInternalId
+        .sort((a, b) => a.data.userInternalId.localeCompare(b.data.userInternalId))
+        // Select only first 4 members
+        .slice(0, 4)
+        .map(({ data }) => channelMemberLinkedObject(data));
+    }
+  }
+
   return shallowClone(channel, {
     markAsRead: () => markAsRead(channel.channelInternalId),
+    previewMembers,
   });
 };

package/src/utils/linkedObject/channelMemberLinkedObject.ts

@@ -0,0 +1,20 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { userLinkedObject } from './userLinkedObject';
+
+export const channelMemberLinkedObject = (
+  channelMember: Amity.Membership<'channel'>,
+): Amity.Membership<'channel'> => {
+  const getUser = (): Amity.User | undefined => {
+    const cacheKey = ['user', 'get', channelMember.userId];
+    const internalUser = pullFromCache<Amity.InternalUser>(cacheKey)?.data;
+
+    return internalUser ? userLinkedObject(internalUser) : undefined;
+  };
+
+  return {
+    ...channelMember,
+    get user() {
+      return getUser();
+    },
+  };
+};

package/src/utils/linkedObject/communityLinkedObject.ts

@@ -0,0 +1,57 @@
+import { InvitationTypeEnum } from '~/@types';
+import { getMyJoinRequest } from '~/communityRepository/internalAPI/getMyJoinRequest';
+import { joinRequest } from '~/communityRepository/internalAPI/joinCommunity';
+import { getJoinRequests } from '~/communityRepository/observers/getJoinRequests';
+import { createInvitations } from '~/invitationRepository/internalApi';
+import { getInvitation } from '~/invitationRepository/internalApi/getInvitation';
+import { getInvitations } from '~/invitationRepository/observers/getInvitations';
+
+export const communityLinkedObject = (community: Amity.InternalCommunity): Amity.Community => {
+  return {
+    ...community,
+    createInvitations: async (userIds: string[]): Promise<void> => {
+      await createInvitations({
+        type: InvitationTypeEnum.CommunityMemberInvite,
+        targetType: 'community',
+        targetId: community.communityId,
+        userIds,
+      });
+    },
+    getMemberInvitations: (
+      params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
+      callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+    ): Amity.Unsubscriber => {
+      return getInvitations(
+        {
+          ...params,
+          targetId: community.communityId,
+          targetType: 'community',
+          type: InvitationTypeEnum.CommunityMemberInvite,
+        },
+        callback,
+      );
+    },
+    getInvitation: async () => {
+      const { data } = await getInvitation('community', community.communityId);
+      return data;
+    },
+    join: async () => joinRequest(community.communityId),
+
+    getJoinRequests: (
+      params: Omit<Amity.QueryJoinRequest, 'communityId'>,
+      callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+    ): Amity.Unsubscriber => {
+      return getJoinRequests(
+        {
+          ...params,
+          communityId: community.communityId,
+        },
+        callback,
+      );
+    },
+    getMyJoinRequest: async () => {
+      const { data } = await getMyJoinRequest(community.communityId);
+      return data;
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -11,6 +11,10 @@ import { channelLinkedObject } from './channelLinkedObject';
 import { adLinkedObject } from './adLinkedObject';
 import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
 import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
+import { communityLinkedObject } from './communityLinkedObject';
+import { invitationLinkedObject } from './invitationLinkedObject';
+import { joinRequestLinkedObject } from './joinRequestLinkedObject';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -26,4 +30,8 @@ export const LinkedObject = {
   channel: channelLinkedObject,
   pinnedPost: pinnedPostLinkedObject,
   notificationTray: notificationTrayLinkedObject,
+  community: communityLinkedObject,
+  invitation: invitationLinkedObject,
+  joinRequest: joinRequestLinkedObject,
+  channelMember: channelMemberLinkedObject,
 };

package/src/utils/linkedObject/invitationLinkedObject.ts

@@ -0,0 +1,37 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
+import { acceptInvitation, rejectInvitation } from '~/invitationRepository/internalApi';
+
+export const invitationLinkedObject = (invitation: Amity.InternalInvitation): Amity.Invitation => {
+  return {
+    ...invitation,
+    get user(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.invitedUserPublicId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get createdBy(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.inviterUserPublicId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get target(): Amity.InvitationTarget<Amity.InvitationTargetType> | undefined {
+      if (invitation.targetType === 'community') {
+        const cacheData = pullFromCache<Amity.InternalCommunity>([
+          'community',
+          'get',
+          invitation.targetId,
+        ]);
+        if (cacheData?.data) return cacheData.data;
+        return undefined;
+      }
+      return undefined;
+    },
+    accept: async () => {
+      await acceptInvitation(invitation._id);
+    },
+    reject: async () => {
+      await rejectInvitation(invitation._id);
+    },
+  };
+};

package/src/utils/linkedObject/joinRequestLinkedObject.ts

@@ -0,0 +1,31 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
+import { approveJoinRequest } from '~/communityRepository/joinRequest/internalAPI/approveJoinRequest';
+import { cancelJoinRequest } from '~/communityRepository/joinRequest/internalAPI/cancelJoinRequest';
+import { rejectJoinRequest } from '~/communityRepository/joinRequest/internalAPI/rejectJoinRequest';
+
+export const joinRequestLinkedObject = (
+  joinRequest: Amity.InternalJoinRequest,
+): Amity.JoinRequest => {
+  return {
+    ...joinRequest,
+    get user(): Amity.User | undefined {
+      const user = pullFromCache<Amity.InternalUser>([
+        'user',
+        'get',
+        joinRequest.requestorPublicId,
+      ])?.data;
+      if (!user) return undefined;
+      return userLinkedObject(user);
+    },
+    cancel: async () => {
+      await cancelJoinRequest(joinRequest);
+    },
+    approve: async () => {
+      await approveJoinRequest(joinRequest);
+    },
+    reject: async () => {
+      await rejectJoinRequest(joinRequest);
+    },
+  };
+};