@amityco/ts-sdk 7.4.1-0e170b02.0 → 7.4.1-108e44a8.0

package/dist/utils/linkedObject/communityLinkedObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"communityLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/communityLinkedObject.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,cAAe,MAAM,iBAAiB,KAAG,MAAM,SAiDhF,CAAC"}
+{"version":3,"file":"communityLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/communityLinkedObject.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,cAAe,MAAM,iBAAiB,KAAG,MAAM,SA+ChF,CAAC"}

package/dist/utils/linkedObject/joinRequestLinkedObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"joinRequestLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/joinRequestLinkedObject.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,uBAAuB,gBACrB,MAAM,mBAAmB,KACrC,MAAM,WAkBR,CAAC"}
+{"version":3,"file":"joinRequestLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/joinRequestLinkedObject.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,uBAAuB,gBACrB,MAAM,mBAAmB,KACrC,MAAM,WAgBR,CAAC"}

package/dist/utils/tests/dummy/comment.d.ts

@@ -23,7 +23,7 @@ export declare const generateComment: (params?: Partial<Amity.InternalComment>)
     referenceType: Amity.CommentReferenceType;
     dataType?: any;
     dataTypes?: any[] | undefined;
-    data?: string | Amity.ContentDataText | Amity.ContentDataFile | Amity.ContentDataImage | Amity.ContentDataVideo | Amity.ContentDataPoll | Record<string, unknown> | undefined;
+    data?: string | Record<string, unknown> | Amity.ContentDataText | Amity.ContentDataFile | Amity.ContentDataImage | Amity.ContentDataVideo | Amity.ContentDataPoll | undefined;
     metadata?: Record<string, any> | undefined;
     flagCount: number;
     hashFlag: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.4.1-0e170b02.0",
+  "version": "7.4.1-108e44a8.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/events.ts

@@ -188,7 +188,7 @@ declare global {
     };
 
     type LocalCommunityEvents = {
-      'local.community.joined': Amity.CommunityMembershipPayload; // v3 join community
+      'local.community.joined': Amity.CommunityMembershipPayload;
       'local.community.left': Amity.CommunityMembershipPayload;
       'local.community.roleAdded': Amity.ProcessedCommunityPayload;
       'local.community.roleRemoved': Amity.ProcessedCommunityPayload;
@@ -265,7 +265,7 @@ declare global {
       'local.invitation.updated': Amity.InternalInvitation[];
       'local.invitation.deleted': Amity.InternalInvitation[];
 
-      'local.community.join': Amity.InternalJoinRequest[]; // v4 join community with status
+      'v4.local.community.joined': Amity.InternalJoinRequest[];
 
       'local.joinRequest.created': Amity.InternalJoinRequest[];
       'local.joinRequest.updated': Amity.InternalJoinRequest[];

package/src/@types/domains/community.ts

@@ -159,6 +159,16 @@ declare global {
       page?: string;
     };
 
+    type QueryJoinRequestList = {
+      communityIds: string[];
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      page?: string;
+    };
+
     type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
 
     type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
@@ -166,6 +176,8 @@ declare global {
 
     type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
 
+    type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
+
     type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
       Omit<SearchQueryCommunities, 'page'>
     >;
@@ -188,6 +200,11 @@ declare global {
       Pick<QueryJoinRequest, 'page'>
     >;
 
+    type JoinRequestListLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequestList, 'page'>
+    >;
+
     type QueryCommunityMembers = {
       communityId: string;
       memberships?: ('banned' | 'member')[];
@@ -257,7 +274,7 @@ declare global {
         callback: Amity.LiveCollectionCallback<Amity.Invitation>,
       ) => Amity.Unsubscriber;
       getInvitation: () => Promise<Amity.Invitation | undefined>;
-      join: () => Promise<Amity.JoinResult>;
+      join: Promise<Amity.JoinResult>;
       getJoinRequests: (
         params: QueryJoinRequest,
         callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,

package/src/@types/domains/joinRequest.ts

@@ -35,10 +35,10 @@ declare global {
       requestorInternalId: string;
       requestorPublicId: string;
 
-      respondedAt: Amity.timestamp;
-      responderId: string;
-      responderInternalId: string;
-      responderPublicId: string;
+      respondedAt: Amity.timestamp | null;
+      responderId: string | null;
+      responderInternalId: string | null;
+      responderPublicId: string | null;
 
       status: Amity.JoinRequestStatus;
       targetId: string;
@@ -58,9 +58,9 @@ declare global {
       };
 
     type JoinRequestLinkedObject = {
-      cancel: () => Promise<void>;
-      approve: () => Promise<void>;
-      reject: () => Promise<void>;
+      cancel: () => void;
+      approve: () => void;
+      reject: () => void;
     };
   }
 }

package/src/@types/domains/notification.ts

@@ -10,6 +10,7 @@ declare global {
       POST_REACT = 'reaction_on_post',
       COMMENT_REACT = 'reaction_on_comment',
       REPLY_REACT = 'reaction_on_reply',
+      RESPONSE_JOIN_REQUEST = 'respond_on_join_request',
     }
 
     const enum TrayAction {
@@ -19,6 +20,7 @@ declare global {
       REACTION = 'reaction',
       MENTION = 'mention',
       REPLY = 'reply',
+      JOIN_REQUEST = 'join_request',
     }
 
     type RawNotificationTrayItem = {

package/src/communityRepository/api/getCommunities.ts

@@ -28,12 +28,14 @@ export const getCommunities = async (
   const client = getActiveClient();
   client.log('community/getCommunities', communityIds);
 
+  const encodedCommunityIds = communityIds.map(communityId => encodeURIComponent(communityId));
+
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/list`,
     {
       params: {
-        communityIds,
+        communityIds: encodedCommunityIds,
         includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
       },
     },

package/src/communityRepository/communityMembership/events/index.ts

@@ -12,3 +12,4 @@ export * from './onCommunityJoined';
 export * from './onCommunityLeft';
 export * from './onLocalCommunityJoined';
 export * from './onLocalCommunityLeft';
+export * from './onLocalCommunityJoin';

package/src/communityRepository/communityMembership/events/onLocalCommunityJoin.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+export const onLocalCommunityJoin = (
+  callback: (joinRequest: Amity.InternalJoinRequest) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.InternalJoinRequest[]) => {
+    callback(rawPayload[0]);
+  };
+
+  const disposers = [
+    createEventSubscriber(client, 'onCommunityUpdate', 'v4.local.community.joined', filter),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/communityRepository/internalAPI/joinCommunity.ts

@@ -1,8 +1,10 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { upsertInCache } from '~/cache/api/upsertInCache';
 import { prepareCommunityJoinRequestPayload } from '~/communityRepository/utils';
 import { fireEvent } from '~/core/events';
-import { JoinResultStatusEnum } from '~/@types/domains/joinRequest';
+import { JoinRequestStatusEnum, JoinResultStatusEnum } from '~/@types/domains/joinRequest';
 import { joinRequestLinkedObject } from '~/utils/linkedObject/joinRequestLinkedObject';
 
 /* begin_public_function
@@ -37,10 +39,25 @@ export const joinRequest = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('local.community.join', data.joinRequests);
-
   const status =
-    data.joinRequests.length === 0 ? JoinResultStatusEnum.Success : JoinResultStatusEnum.Pending;
+    data.joinRequests[0].status === JoinRequestStatusEnum.Approved
+      ? JoinResultStatusEnum.Success
+      : JoinResultStatusEnum.Pending;
+
+  if (status === JoinResultStatusEnum.Success && client.cache) {
+    const community = pullFromCache<Amity.Community>(['community', 'get', communityId])?.data;
+
+    if (community) {
+      const updatedCommunity = {
+        ...community,
+        isJoined: true,
+      };
+
+      upsertInCache(['community', 'get', communityId], updatedCommunity);
+    }
+  }
+
+  fireEvent('v4.local.community.joined', data.joinRequests);
 
   return status === JoinResultStatusEnum.Success
     ? { status }

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

@@ -29,14 +29,10 @@ export const approveJoinRequest = async (
   const { data } = await client.http.post<{ success: boolean }>(
     `/api/v4/communities/${joinRequest.targetId}/join/approve`,
     {
-      params: {
-        userId: joinRequest.userId,
-      },
+      userId: joinRequest.requestorInternalId,
     },
   );
 
-  // TODO : Check cache id
-
   const joinRequestCache = pullFromCache<Amity.InternalJoinRequest>([
     'joinRequest',
     'get',

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

@@ -27,11 +27,6 @@ export const cancelJoinRequest = async (
 
   const { data } = await client.http.delete<{ success: boolean }>(
     `/api/v4/communities/${joinRequest.targetId}/join`,
-    {
-      params: {
-        userId: joinRequest.userId,
-      },
-    },
   );
 
   const joinRequestCache = pullFromCache<Amity.InternalJoinRequest>([

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

@@ -28,6 +28,9 @@ export const rejectJoinRequest = async (
 
   const { data } = await client.http.post<{ success: boolean }>(
     `/api/v4/communities/${joinRequest.targetId}/join/reject`,
+    {
+      userId: joinRequest.requestorInternalId,
+    },
   );
 
   const joinRequestCache = pullFromCache<Amity.InternalJoinRequest>([

package/src/communityRepository/observers/getCommunities/CommunitiesLiveCollectionController.ts

@@ -25,8 +25,10 @@ import {
   onLocalCommunityJoined,
   onLocalCommunityLeft,
   onCommunityUserChanged,
+  onLocalCommunityJoin,
 } from '~/communityRepository/communityMembership';
 import { isNonNullable } from '~/utils';
+import { convertEventPayload } from '~/utils/event';
 
 export class CommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -92,6 +94,10 @@ export class CommunityLiveCollectionController extends LiveCollectionController<
       { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnMemberCountChanged },
       { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
       { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      {
+        fn: convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
+        action: EnumCommunityActions.OnCommunityUpdated,
+      },
     ]);
   }
 

package/src/communityRepository/observers/getCommunity.ts

@@ -9,7 +9,9 @@ import {
   onCommunityLeft,
   onLocalCommunityJoined,
   onLocalCommunityLeft,
+  onLocalCommunityJoin,
 } from '../communityMembership/events';
+import { convertEventPayload } from '~/utils/event';
 
 /* begin_public_function
   id: community.get
@@ -47,6 +49,7 @@ export const getCommunity = (
     onCommunityUserBanned,
     onCommunityUserUnbanned,
     onCommunityUserChanged,
+    convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
   ]);
 };
 /* end_public_function */

package/src/communityRepository/observers/getJoinRequestList/JoinRequestListLiveCollectionController.ts

@@ -0,0 +1,130 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { JoinRequestListPaginationController } from './JoinRequestListPaginationController';
+import { JoinRequestListQueryStreamController } from './JoinRequestListQueryStreamController';
+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 JoinRequestListLiveCollectionController extends LiveCollectionController<
+  'joinRequest',
+  Amity.JoinRequestListLiveCollection,
+  Amity.JoinRequest,
+  JoinRequestListPaginationController
+> {
+  private queryStreamController: JoinRequestListQueryStreamController;
+
+  private query: Amity.JoinRequestListLiveCollection;
+
+  constructor(
+    query: Amity.JoinRequestListLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['joinRequestList', 'collection', queryStreamId];
+    const paginationController = new JoinRequestListPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new JoinRequestListQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityJoinRequestPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.JoinRequestListLiveCollectionCache>(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.JoinRequestListLiveCollectionCache>(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.communityIds && this.query.communityIds.length > 0) {
+      joinRequest = joinRequest.filter(joinRequest =>
+        this.query.communityIds.some(id => id === joinRequest.targetId),
+      );
+    }
+
+    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/getJoinRequestList/JoinRequestListPaginationController.ts

@@ -0,0 +1,30 @@
+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 JoinRequestListPaginationController extends PaginationController<
+  'joinRequest',
+  Amity.JoinRequestListLiveCollection
+> {
+  async getRequest(queryParams: Amity.JoinRequestListLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, communityIds, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const encodedChannelIds = communityIds.map(communityId => encodeURIComponent(communityId));
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.CommunityJoinRequestPayload & Amity.Pagination
+    >(`/api/v4/communities/join/requests`, {
+      params: {
+        ...params,
+        options,
+        communityIds: encodedChannelIds,
+      },
+    });
+
+    return queryResponse;
+  }
+}

package/src/communityRepository/observers/getJoinRequestList/JoinRequestListQueryStreamController.ts

@@ -0,0 +1,112 @@
+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 JoinRequestListQueryStreamController extends QueryStreamController<
+  Amity.CommunityJoinRequestPayload,
+  Amity.JoinRequestListLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.CommunityJoinRequestPayload,
+  ) => Amity.ProcessedJoinRequestPayload;
+
+  constructor(
+    query: Amity.JoinRequestListLiveCollection,
+    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.JoinRequestListLiveCollectionCache>(
+        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.JoinRequestListLiveCollectionCache>(
+        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/getJoinRequestList/enum.ts

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

package/src/communityRepository/observers/getJoinRequestList.ts

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

package/src/communityRepository/observers/index.ts

@@ -5,3 +5,4 @@ export * from './getTrendingCommunities';
 export * from './getRecommendedCommunities';
 
 export * from './semanticSearchCommunities';
+export * from './getJoinRequestList';

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

@@ -35,9 +35,7 @@ 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);
-    },
+    join: joinRequest(community.communityId),
     getJoinRequests: (
       params: Omit<Amity.QueryJoinRequest, 'communityId'>,
       callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,