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

package/src/communityRepository/api/queryCommunities.ts

@@ -6,6 +6,7 @@ import { getResolver } from '~/core/model';
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -49,6 +50,7 @@ export const queryCommunities = async (
         ...restParams,
         isDeleted: inferIsDeleted(includeDeleted),
         filter: membership,
+        includeDiscoverablePrivateCommunity: params?.includeDiscoverablePrivateCommunity ?? true,
         options,
       },
     },
@@ -68,5 +70,9 @@ export const queryCommunities = async (
     saveCommunityUsers(data.communities, data.communityUsers);
   }
 
-  return { data: communities, cachedAt, paging };
+  return {
+    data: communities.map(community => LinkedObject.community(community)),
+    cachedAt,
+    paging,
+  };
 };

package/src/communityRepository/api/updateCommunity.ts

@@ -5,14 +5,15 @@ import { fireEvent } from '~/core/events';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload, prepareCommunityRequest } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: community.update
 */
 /**
  * ```js
- * import { updateCommunity } from '@amityco/ts-sdk-react-native'
- * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * import { updateCommunity } from '@amityco/ts-sdk'
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
  * ```
  *
  * Updates an {@link Amity.Community}
@@ -28,7 +29,14 @@ export const updateCommunity = async (
   communityId: Amity.Community['communityId'],
   patch: Patch<
     Amity.Community,
-    'displayName' | 'avatarFileId' | 'description' | 'postSetting' | 'tags' | 'metadata'
+    | 'displayName'
+    | 'avatarFileId'
+    | 'description'
+    | 'postSetting'
+    | 'tags'
+    | 'metadata'
+    | 'isDiscoverable'
+    | 'requiresJoinApproval'
   > &
     Amity.CommunityStorySettings,
 ): Promise<Amity.Cached<Amity.Community>> => {
@@ -53,7 +61,9 @@ export const updateCommunity = async (
   const { communities } = data;
 
   return {
-    data: communities.find(community => community.communityId === communityId)!,
+    data: LinkedObject.community(
+      communities.find(community => community.communityId === communityId)!,
+    ),
     cachedAt,
   };
 };

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityJoined = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.joined', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityLeft = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.left', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserAdded = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userAdded', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserBanned = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userBanned', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserChanged = (
-  callback: (community: Amity.Community, members: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, members: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userChanged', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserRemoved = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userRemoved', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserRoleAdded = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.roleAdded', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserRoleRemoved = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.roleRemoved', callback);

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

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserUnbanned = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userUnbanned', callback);

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/communityMembership/events/onLocalCommunityJoined.ts

@@ -1,5 +1,5 @@
 import { createLocalCommunityMemberEventSubscriber } from './utils';
 
 export const onLocalCommunityJoined = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createLocalCommunityMemberEventSubscriber('local.community.joined', callback);

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

@@ -1,5 +1,5 @@
 import { createLocalCommunityMemberEventSubscriber } from './utils';
 
 export const onLocalCommunityLeft = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createLocalCommunityMemberEventSubscriber('local.community.left', callback);

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

@@ -16,5 +16,5 @@ import { createLocalCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onLocalCommunityUserAdded = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createLocalCommunityMemberEventSubscriber('local.community.userAdded', callback);

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

@@ -16,5 +16,5 @@ import { createLocalCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onLocalCommunityUserRemoved = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ) => createLocalCommunityMemberEventSubscriber('local.community.userRemoved', callback);

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

@@ -22,7 +22,9 @@ import { getResolver } from '~/core/model';
  */
 export const onUserDeleted =
   (communityId: string) =>
-  (callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void) => {
+  (
+    callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
+  ) => {
     const client = getActiveClient();
 
     const filter = (payload: Amity.UserPayload) => {

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

@@ -53,7 +53,7 @@ function getEventRelatedMember(
 
 export const createCommunityMemberEventSubscriber = (
   event: keyof Amity.MqttCommunityUserEvents,
-  callback: (community: Amity.Community, members: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, members: Amity.Membership<'community'>[]) => void,
 ) => {
   const client = getActiveClient();
 
@@ -102,7 +102,7 @@ export const createCommunityMemberEventSubscriber = (
 
 export const createLocalCommunityMemberEventSubscriber = (
   event: keyof Amity.LocalCommunityEvents,
-  callback: (community: Amity.Community, members: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, members: Amity.Membership<'community'>[]) => void,
 ) => {
   const client = getActiveClient();
 

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersQueryStreamController.ts

@@ -70,7 +70,10 @@ export class CommunityMembersQueryStreamController extends QueryStreamController
   }
 
   reactor(action: EnumCommunityMemberActions) {
-    return (community: Amity.Community, communityMembers: Amity.Membership<'community'>[]) => {
+    return (
+      community: Amity.InternalCommunity,
+      communityMembers: Amity.Membership<'community'>[],
+    ) => {
       const collection = pullFromCache<Amity.CommunityMemberLiveCollectionCache>(
         this.cacheKey,
       )?.data;
@@ -97,7 +100,10 @@ export class CommunityMembersQueryStreamController extends QueryStreamController
   subscribeRTE(
     createSubscriber: {
       fn: (
-        reactor: (channel: Amity.Community, communityUser: Amity.Membership<'community'>[]) => void,
+        reactor: (
+          channel: Amity.InternalCommunity,
+          communityUser: Amity.Membership<'community'>[],
+        ) => void,
       ) => Amity.Unsubscriber;
       action: EnumCommunityMemberActions;
     }[],

package/src/communityRepository/communityMembership/observers/getMembers/enums.ts

@@ -10,4 +10,5 @@ export enum EnumCommunityMemberActions {
   OnCommunityUserAdded = 'OnCommunityUserAdded',
   onCommunityUserRemoved = 'onCommunityUserRemoved',
   OnUserDeleted = 'OnUserDeleted',
+  OnLocalCommunityJoin = 'OnLocalCommunityJoin',
 }

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersQueryStreamController.ts

@@ -70,7 +70,10 @@ export class SearchCommunityMembersQueryStreamController extends QueryStreamCont
   }
 
   reactor(action: EnumCommunityMemberActions) {
-    return (community: Amity.Community, communityMembers: Amity.Membership<'community'>[]) => {
+    return (
+      community: Amity.InternalCommunity,
+      communityMembers: Amity.Membership<'community'>[],
+    ) => {
       const collection = pullFromCache<Amity.SearchCommunityMemberLiveCollectionCache>(
         this.cacheKey,
       )?.data;
@@ -95,7 +98,10 @@ export class SearchCommunityMembersQueryStreamController extends QueryStreamCont
   subscribeRTE(
     createSubscriber: {
       fn: (
-        reactor: (channel: Amity.Community, communityUser: Amity.Membership<'community'>[]) => void,
+        reactor: (
+          channel: Amity.InternalCommunity,
+          communityUser: Amity.Membership<'community'>[],
+        ) => void,
       ) => Amity.Unsubscriber;
       action: EnumCommunityMemberActions;
     }[],

package/src/communityRepository/communityMembership/observers/searchMembers/enums.ts

@@ -1,5 +1,6 @@
 export enum EnumCommunityMemberActions {
   OnCommunityJoined = 'onCommunityJoined',
+  OnLocalCommunityJoin = 'onLocalCommunityJoin',
   OnCommunityLeft = 'onCommunityLeft',
   OnCommunityUserBanned = 'onCommunityUserBanned',
   OnCommunityUserChanged = 'onCommunityUserChanged',

package/src/communityRepository/communityModeration/events/onLocalCommunityRoleAdded.ts

@@ -17,7 +17,7 @@ import { createEventSubscriber } from '~/core/events';
  * @category Community Events
  */
 export const onLocalCommunityRoleAdded = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 

package/src/communityRepository/communityModeration/events/onLocalCommunityRoleRemoved.ts

@@ -17,7 +17,7 @@ import { createEventSubscriber } from '~/core/events';
  * @category Community Events
  */
 export const onLocalCommunityRoleRemoved = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+  callback: (community: Amity.InternalCommunity, member: Amity.Membership<'community'>[]) => void,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 

package/src/communityRepository/events/onCommunityCreated.ts

@@ -15,5 +15,5 @@ import { createCommunityEventSubscriber } from './utils';
  *
  * @category Community Events
  */
-export const onCommunityCreated = (callback: Amity.Listener<Amity.Community>) =>
+export const onCommunityCreated = (callback: Amity.Listener<Amity.InternalCommunity>) =>
   createCommunityEventSubscriber('community.created', callback);

package/src/communityRepository/events/onCommunityDeleted.ts

@@ -15,5 +15,5 @@ import { createCommunityEventSubscriber } from './utils';
  *
  * @category Community Events
  */
-export const onCommunityDeleted = (callback: Amity.Listener<Amity.Community>) =>
+export const onCommunityDeleted = (callback: Amity.Listener<Amity.InternalCommunity>) =>
   createCommunityEventSubscriber('community.deleted', callback);

package/src/communityRepository/events/onCommunityUpdated.ts

@@ -15,5 +15,5 @@ import { createCommunityEventSubscriber } from './utils';
  *
  * @category Community Events
  */
-export const onCommunityUpdated = (callback: Amity.Listener<Amity.Community>) =>
+export const onCommunityUpdated = (callback: Amity.Listener<Amity.InternalCommunity>) =>
   createCommunityEventSubscriber('community.updated', callback);

package/src/communityRepository/events/utils.ts

@@ -7,7 +7,7 @@ import { prepareCommunityPayload } from '../utils';
 
 export const createCommunityEventSubscriber = (
   event: keyof Amity.MqttCommunityEvents,
-  callback: Amity.Listener<Amity.Community>,
+  callback: Amity.Listener<Amity.InternalCommunity>,
 ) => {
   const client = getActiveClient();
 

package/src/communityRepository/internalAPI/getMyJoinRequest.ts

@@ -0,0 +1,43 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareCommunityJoinRequestPayload } from '~/communityRepository/utils';
+import { joinRequestLinkedObject } from '~/utils/linkedObject/joinRequestLinkedObject';
+
+/* begin_public_function
+  id: community.getMyJoinRequest
+*/
+/**
+ * ```js
+ * import { community } from '@amityco/ts-sdk'
+ * const isJoined = await community.getMyJoinRequest('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A success boolean if the {@link Amity.Community} was joined
+ *
+ * @category Community API
+ * @async
+ */
+export const getMyJoinRequest = async (
+  communityId: Amity.Community['communityId'],
+): Promise<Amity.Cached<Amity.JoinRequest | undefined>> => {
+  const client = getActiveClient();
+  client.log('community/myJoinRequest', communityId);
+
+  const { data: payload } = await client.http.get<Amity.CommunityJoinRequestPayload>(
+    `/api/v4/communities/${communityId}/join/me`,
+  );
+
+  const data = prepareCommunityJoinRequestPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.joinRequests[0] ? joinRequestLinkedObject(data.joinRequests[0]) : undefined,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/communityRepository/internalAPI/joinCommunity.ts

@@ -0,0 +1,66 @@
+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 { JoinRequestStatusEnum, JoinResultStatusEnum } from '~/@types/domains/joinRequest';
+import { joinRequestLinkedObject } from '~/utils/linkedObject/joinRequestLinkedObject';
+
+/* begin_public_function
+  id: community.join
+*/
+/**
+ * ```js
+ * import { community } from '@amityco/ts-sdk'
+ * const isJoined = await community.join('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A status join result
+ *
+ * @category Community API
+ * @async
+ */
+export const joinRequest = async (
+  communityId: Amity.Community['communityId'],
+): Promise<Amity.JoinResult> => {
+  const client = getActiveClient();
+  client.log('community/joinRequest', communityId);
+
+  const { data: payload } = await client.http.post<Amity.CommunityJoinRequestPayload>(
+    `/api/v4/communities/${communityId}/join`,
+  );
+
+  const data = prepareCommunityJoinRequestPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const status =
+    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 }
+    : { status, request: joinRequestLinkedObject(data.joinRequests[0]) };
+};
+/* end_public_function */

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

@@ -0,0 +1,3 @@
+export * from './onJoinRequestCreated';
+export * from './onJoinRequestUpdated';
+export * from './onJoinRequestDeleted';

package/src/communityRepository/joinRequest/events/onJoinRequestCreated.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onJoinRequestCreated } from '@amityco/ts-sdk'
+ * const dispose = onJoinRequestCreated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category JoinRequest Events
+ */
+export const onJoinRequestCreated = (
+  callback: Amity.Listener<Amity.InternalJoinRequest[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(client, 'onJoinRequestCreated', 'local.joinRequest.created', payload =>
+      callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/communityRepository/joinRequest/events/onJoinRequestDeleted.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onJoinRequestDeleted } from '@amityco/ts-sdk'
+ * const dispose = onJoinRequestDeleted(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category JoinRequest Events
+ */
+export const onJoinRequestDeleted = (
+  callback: Amity.Listener<Amity.InternalJoinRequest[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(client, 'onJoinRequestDeleted', 'local.joinRequest.deleted', payload =>
+      callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/communityRepository/joinRequest/events/onJoinRequestUpdated.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onJoinRequestUpdated } from '@amityco/ts-sdk'
+ * const dispose = onJoinRequestUpdated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category JoinRequest Events
+ */
+export const onJoinRequestUpdated = (
+  callback: Amity.Listener<Amity.InternalJoinRequest[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(client, 'onJoinRequestUpdated', 'local.joinRequest.updated', payload =>
+      callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

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

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