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

package/src/communityRepository/joinRequest/internalAPI/rejectJoinRequest.ts

@@ -0,0 +1,52 @@
+import { fireEvent } from '~/core/events';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+import { JoinRequestStatusEnum } from '~/@types/domains/joinRequest';
+
+/* begin_public_function
+  id: joinRequest.reject
+*/
+/**
+ * ```js
+ * import { joinRequest } from '@amityco/ts-sdk'
+ * const isRejected = await joinRequest.reject()
+ * ```
+ *
+ * Rejects a {@link Amity.JoinRequest} object
+ *
+ * @param joinRequest the {@link Amity.JoinRequest} to reject
+ * @returns A success boolean if the {@link Amity.JoinRequest} was rejected
+ *
+ * @category Join Request API
+ * @async
+ */
+export const rejectJoinRequest = async (
+  joinRequest: Amity.InternalJoinRequest,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('joinRequest/rejectJoinRequest', joinRequest.joinRequestId);
+
+  const { data } = await client.http.post<{ success: boolean }>(
+    `/api/v4/communities/${joinRequest.targetId}/join/reject`,
+    {
+      userId: joinRequest.requestorInternalId,
+    },
+  );
+
+  const joinRequestCache = pullFromCache<Amity.InternalJoinRequest>([
+    'joinRequest',
+    'get',
+    joinRequest.joinRequestId,
+  ])?.data;
+
+  if (joinRequestCache) {
+    upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+      status: JoinRequestStatusEnum.Rejected,
+    });
+
+    fireEvent('local.joinRequest.updated', [joinRequestCache]);
+  }
+
+  return data.success;
+};
+/* end_public_function */

package/src/communityRepository/observers/getJoinRequests/JoinRequestsLiveCollectionController.ts

@@ -0,0 +1,126 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { JoinRequestsPaginationController } from './JoinRequestsPaginationController';
+import { JoinRequestsQueryStreamController } from './JoinRequestsQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { prepareCommunityJoinRequestPayload } from '~/communityRepository/utils';
+import { EnumJoinRequestAction } from './enum';
+import { isNonNullable } from '~/utils';
+import { joinRequestLinkedObject } from '~/utils/linkedObject/joinRequestLinkedObject';
+import {
+  onJoinRequestCreated,
+  onJoinRequestDeleted,
+  onJoinRequestUpdated,
+} from '~/communityRepository/joinRequest/events/';
+
+export class JoinRequestsLiveCollectionController extends LiveCollectionController<
+  'joinRequest',
+  Amity.JoinRequestLiveCollection,
+  Amity.JoinRequest,
+  JoinRequestsPaginationController
+> {
+  private queryStreamController: JoinRequestsQueryStreamController;
+
+  private query: Amity.JoinRequestLiveCollection;
+
+  constructor(
+    query: Amity.JoinRequestLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['joinRequest', 'collection', queryStreamId];
+    const paginationController = new JoinRequestsPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new JoinRequestsQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityJoinRequestPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.JoinRequestLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: this.query,
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommunityJoinRequestPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'joinRequest'>) {
+    const joinRequestResponse = response as unknown as Amity.CommunityJoinRequestPayload &
+      Partial<Amity.Pagination>;
+    this.queryStreamController.appendToQueryStream(joinRequestResponse, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onJoinRequestCreated, action: EnumJoinRequestAction.OnLocalJoinRequestCreated },
+      { fn: onJoinRequestUpdated, action: EnumJoinRequestAction.OnLocalJoinRequestUpdated },
+      { fn: onJoinRequestDeleted, action: EnumJoinRequestAction.OnLocalJoinRequestDeleted },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.JoinRequestLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalJoinRequest>(['joinRequest', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data)
+        .map(joinRequestLinkedObject),
+    );
+
+    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.JoinRequest[]) {
+    let joinRequest = data;
+
+    if (this.query.status) {
+      joinRequest = joinRequest.filter(joinRequest => joinRequest.status === this.query.status);
+    }
+
+    const sortFn = (() => {
+      switch (this.query.sortBy) {
+        case 'firstCreated':
+          return sortByFirstCreated;
+        case 'lastCreated':
+          return sortByLastCreated;
+        default:
+          return sortByLastCreated;
+      }
+    })();
+
+    joinRequest = joinRequest.sort(sortFn);
+
+    return joinRequest;
+  }
+}

package/src/communityRepository/observers/getJoinRequests/JoinRequestsPaginationController.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 JoinRequestsPaginationController extends PaginationController<
+  'joinRequest',
+  Amity.JoinRequestLiveCollection
+> {
+  async getRequest(queryParams: Amity.JoinRequestLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, communityId, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.CommunityJoinRequestPayload & Amity.Pagination
+    >(`/api/v4/communities/${communityId}/join`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/communityRepository/observers/getJoinRequests/JoinRequestsQueryStreamController.ts

@@ -0,0 +1,108 @@
+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/api/activeClient';
+import { EnumJoinRequestAction } from './enum';
+
+export class JoinRequestsQueryStreamController extends QueryStreamController<
+  Amity.CommunityJoinRequestPayload,
+  Amity.JoinRequestLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.CommunityJoinRequestPayload,
+  ) => Amity.ProcessedJoinRequestPayload;
+
+  constructor(
+    query: Amity.JoinRequestLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.CommunityJoinRequestPayload,
+    ) => Amity.ProcessedJoinRequestPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommunityJoinRequestPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommunityJoinRequestPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.joinRequests.map(joinRequest =>
+          getResolver('joinRequest')({ joinRequestId: joinRequest._id }),
+        ),
+      });
+    } else {
+      const collection = pullFromCache<Amity.JoinRequestLiveCollectionCache>(this.cacheKey)?.data;
+
+      const joinRequests = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...joinRequests,
+            ...response.joinRequests.map(joinRequest =>
+              getResolver('joinRequest')({ joinRequestId: joinRequest._id }),
+            ),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: EnumJoinRequestAction) {
+    return (joinRequest: Amity.InternalJoinRequest[]) => {
+      const collection = pullFromCache<Amity.JoinRequestLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (action === EnumJoinRequestAction.OnLocalJoinRequestUpdated) {
+        const isExist = collection.data.find(id => id === joinRequest[0].joinRequestId);
+        if (!isExist) return;
+      }
+
+      if (action === EnumJoinRequestAction.OnLocalJoinRequestCreated) {
+        collection.data = [
+          ...new Set([
+            ...joinRequest.map(joinRequest => joinRequest.joinRequestId),
+            ...collection.data,
+          ]),
+        ];
+      }
+
+      if (action === EnumJoinRequestAction.OnLocalJoinRequestDeleted) {
+        collection.data = collection.data.filter(id => id !== joinRequest[0].joinRequestId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalJoinRequest[]>) => Amity.Unsubscriber;
+      action: EnumJoinRequestAction;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/communityRepository/observers/getJoinRequests/enum.ts

@@ -0,0 +1,5 @@
+export enum EnumJoinRequestAction {
+  OnLocalJoinRequestCreated = 'OnLocalJoinRequestCreated',
+  OnLocalJoinRequestUpdated = 'OnLocalJoinRequestUpdated',
+  OnLocalJoinRequestDeleted = 'OnLocalJoinRequestDeleted',
+}

package/src/communityRepository/observers/getJoinRequests.ts

@@ -0,0 +1,44 @@
+import { dropFromCache } from '~/cache/api/dropFromCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { JoinRequestsLiveCollectionController } from './getJoinRequests/JoinRequestsLiveCollectionController';
+
+/**
+ * Get Join Requests
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the join request are updated
+ * @returns joinRequests
+ *
+ * @category joinRequest Live Collection
+ *
+ */
+export const getJoinRequests = (
+  params: Amity.JoinRequestLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getJoinRequests: (tmpid: ${timestamp}) > listen`);
+
+  const joinRequestLiveCollection = new JoinRequestsLiveCollectionController(params, callback);
+
+  const disposers = joinRequestLiveCollection.startSubscription();
+
+  const cacheKey = joinRequestLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getJoinRequests (tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/communityRepository/observers/getRecommendedCommunities/RecommendedCommunitiesLiveCollectionController.ts

@@ -15,6 +15,7 @@ import {
   onCommunityUserChanged,
 } from '~/communityRepository/communityMembership';
 import { isNonNullable } from '~/utils';
+import { communityLinkedObject } from '~/utils/linkedObject/communityLinkedObject';
 
 export class RecommendedCommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -94,7 +95,7 @@ export class RecommendedCommunityLiveCollectionController extends LiveCollection
       collection.data
         .map(id => pullFromCache<Amity.Community>(['community', 'get', id]))
         .filter(isNonNullable)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => communityLinkedObject(data)) ?? [];
 
     if (!this.shouldNotify(data) && origin === 'event') return;
 

package/src/communityRepository/observers/getTrendingCommunities/TrendingCommunitiesLiveCollectionController.ts

@@ -15,6 +15,7 @@ import {
   onCommunityUserChanged,
 } from '~/communityRepository/communityMembership';
 import { isNonNullable } from '~/utils';
+import { communityLinkedObject } from '~/utils/linkedObject/communityLinkedObject';
 
 export class TrendingCommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -94,7 +95,7 @@ export class TrendingCommunityLiveCollectionController extends LiveCollectionCon
       collection.data
         .map(id => pullFromCache<Amity.Community>(['community', 'get', id]))
         .filter(isNonNullable)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => communityLinkedObject(data)) ?? [];
 
     if (!this.shouldNotify(data) && origin === 'event') return;
 

package/src/communityRepository/observers/searchCommunities/SearchCommunitiesPaginationController.ts

@@ -22,6 +22,7 @@ export class CommunitiesPaginationController extends PaginationController<
           isDeleted: inferIsDeleted(params.includeDeleted),
           keyword: params.displayName,
           filter: params.membership,
+          includeDiscoverablePrivateCommunity: params.includeDiscoverablePrivateCommunity ?? true,
           options,
         },
       },

package/src/communityRepository/utils/communityWithMembership.ts

@@ -1,5 +1,5 @@
 import { pullFromCache } from '~/cache/api';
-import { getActiveUser } from '~/client';
+import { getActiveUser } from '~/client/api/activeUser';
 
 /*
  * verifies membership status

package/src/communityRepository/utils/payload.ts

@@ -1,5 +1,6 @@
 import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
 import { updateMembershipStatus } from './communityWithMembership';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 const getMatchPostSetting = (value: {
   needApprovalOnPostCreation: Amity.RawCommunity['needApprovalOnPostCreation'];
@@ -29,10 +30,13 @@ export const prepareCommunityPayload = (
 ): Amity.ProcessedCommunityPayload => {
   const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
 
+  // Convert users to internal format
+  const internalUsers = rawPayload.users.map(convertRawUserToInternalUser);
+
   // map users with community
   const mappedCommunityUsers: Array<Amity.Membership<'community'>> = rawPayload.communityUsers.map(
     communityUser => {
-      const user = rawPayload.users.find(user => user.userId === communityUser.userId)!;
+      const user = internalUsers.find(user => user.userId === communityUser.userId)!;
 
       return {
         ...communityUser,
@@ -48,11 +52,33 @@ export const prepareCommunityPayload = (
 
   return {
     ...rawPayload,
+    users: rawPayload.users.map(convertRawUserToInternalUser),
     communities: communityWithMembershipStatus,
     communityUsers: mappedCommunityUsers,
   };
 };
 
+export const prepareCommunityJoinRequestPayload = (
+  rawPayload: Amity.CommunityJoinRequestPayload,
+): Amity.ProcessedJoinRequestPayload => {
+  const mappedJoinRequests: Array<Amity.InternalJoinRequest> = rawPayload.joinRequests.map(
+    joinRequest => {
+      return {
+        ...joinRequest,
+        joinRequestId: joinRequest._id,
+      };
+    },
+  );
+
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
+
+  return {
+    ...rawPayload,
+    joinRequests: mappedJoinRequests,
+    users,
+  };
+};
+
 export const prepareCommunityMembershipPayload = (
   rawPayload: Amity.CommunityMembershipPayload,
 ): Amity.ProcessedCommunityMembershipPayload => {

package/src/core/model/idResolvers.ts

@@ -66,6 +66,7 @@ const idResolvers: Resolvers = {
   notificationTraySeen: ({ userId }) => userId,
 
   invitation: ({ _id }) => _id,
+  joinRequest: ({ joinRequestId }) => joinRequestId,
 };
 
 /**

package/src/core/model/index.ts

@@ -56,6 +56,7 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   notificationTrayItems: 'notificationTrayItem',
 
   invitations: 'invitation',
+  joinRequests: 'joinRequest',
 };
 
 /** hidden */

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/communityLinkedObject.ts

@@ -1,4 +1,7 @@
 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';
@@ -32,5 +35,24 @@ export const communityLinkedObject = (community: Amity.InternalCommunity): Amity
       const { data } = await getInvitation('community', community.communityId);
       return data;
     },
+    join: async (): Promise<Amity.JoinResult> => {
+      return 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

@@ -13,6 +13,7 @@ import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
 import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
 import { communityLinkedObject } from './communityLinkedObject';
 import { invitationLinkedObject } from './invitationLinkedObject';
+import { joinRequestLinkedObject } from './joinRequestLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -30,4 +31,5 @@ export const LinkedObject = {
   notificationTray: notificationTrayLinkedObject,
   community: communityLinkedObject,
   invitation: invitationLinkedObject,
+  joinRequest: joinRequestLinkedObject,
 };

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);
+    },
+  };
+};