@amityco/ts-sdk 7.4.1-d23fab2f.0 → 7.4.1-e8631ca7.0

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.targetId));
+
+    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/utils/linkedObject/communityLinkedObject.ts

@@ -1,7 +1,9 @@
 import { InvitationTypeEnum } from '~/@types';
 import { createInvitations } from '~/invitationRepository/internalApi';
+import { getInvitation } from '~/invitationRepository/internalApi/getInvitation';
+import { getInvitations } from '~/invitationRepository/observers/getInvitations';
 
-export const communityLinkedObject = (community: Amity.RawCommunity): Amity.Community => {
+export const communityLinkedObject = (community: Amity.InternalCommunity): Amity.Community => {
   return {
     ...community,
     createInvitations: async (userIds: string[]): Promise<void> => {
@@ -12,5 +14,23 @@ export const communityLinkedObject = (community: Amity.RawCommunity): Amity.Comm
         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;
+    },
   };
 };

package/src/utils/linkedObject/invitationLinkedObject.ts

@@ -1,12 +1,36 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
 import {
   acceptInvitation,
   cancelInvitation,
   rejectInvitation,
 } from '~/invitationRepository/internalApi';
 
-export const invitationLinkedObject = (invitation: Amity.RawInvitation): Amity.Invitation => {
+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);
     },