@amityco/ts-sdk 7.5.2-4215b84.0 → 7.5.2

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

@@ -1,148 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

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

package/src/invitationRepository/utils/convertRawInvitationToInternalInvitation.ts

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

package/src/invitationRepository/utils/index.ts

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

package/src/invitationRepository/utils/prepareInvitationPayload.ts

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/utils/linkedObject/communityLinkedObject.ts

@@ -1,57 +0,0 @@
-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/invitationLinkedObject.ts

@@ -1,37 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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);
-    },
-  };
-};