@amityco/ts-sdk-react-native 7.5.4-a561051.0 → 7.6.1-f7cc558.0

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

@@ -0,0 +1,25 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+
+/**
+ * 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 = 20, 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

@@ -13,8 +13,11 @@ import {
   onLocalCommunityJoined,
   onLocalCommunityLeft,
   onCommunityUserChanged,
+  onLocalCommunityJoin,
 } from '~/communityRepository/communityMembership';
 import { isNonNullable } from '~/utils';
+import { communityLinkedObject } from '~/utils/linkedObject/communityLinkedObject';
+import { convertEventPayload } from '~/utils/event';
 
 export class RecommendedCommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -81,6 +84,10 @@ export class RecommendedCommunityLiveCollectionController extends LiveCollection
       { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnMemberCountChanged },
       { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
       { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      {
+        fn: convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
+        action: EnumCommunityActions.OnCommunityUpdated,
+      },
     ]);
   }
 
@@ -94,7 +101,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/getRecommendedCommunities/RecommendedCommunitiesPaginationController.ts

@@ -14,7 +14,11 @@ export class RecommendedCommunitiesPaginationController extends PaginationContro
     queryParams: Amity.RecommendedCommunityLiveCollection,
     token: string | undefined,
   ) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const {
+      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
+      includeDiscoverablePrivateCommunity,
+      ...params
+    } = queryParams;
     const options = token ? { token } : { limit };
 
     const { data: queryResponse } = await this.http.get<Amity.CommunityPayload & Amity.Pagination>(
@@ -23,6 +27,7 @@ export class RecommendedCommunitiesPaginationController extends PaginationContro
         params: {
           ...params,
           options,
+          includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
         },
       },
     );

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

@@ -66,7 +66,7 @@ export class RecommendedCommunitiesQueryStreamController extends QueryStreamCont
   }
 
   reactor(action: EnumCommunityActions | EnumCommunityMemberActions) {
-    return (community: Amity.Community) => {
+    return (community: Amity.InternalCommunity) => {
       const collection = pullFromCache<Amity.RecommendedCommunityLiveCollectionCache>(
         this.cacheKey,
       )?.data;
@@ -79,7 +79,7 @@ export class RecommendedCommunitiesQueryStreamController extends QueryStreamCont
 
   subscribeRTE(
     createSubscriber: {
-      fn: (reactor: (channel: Amity.Community) => void) => Amity.Unsubscriber;
+      fn: (reactor: (channel: Amity.InternalCommunity) => void) => Amity.Unsubscriber;
       action: EnumCommunityActions | EnumCommunityMemberActions;
     }[],
   ) {

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

@@ -1,4 +1,5 @@
 export enum EnumCommunityActions {
   OnCommunityDeleted = 'onCommunityDeleted',
   OnCommunityUpdated = 'onCommunityUpdated',
+  OnLocalCommunityJoin = 'onLocalCommunityJoin',
 }

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

@@ -13,8 +13,12 @@ import {
   onLocalCommunityJoined,
   onLocalCommunityLeft,
   onCommunityUserChanged,
+  onLocalCommunityJoin,
 } from '~/communityRepository/communityMembership';
+
 import { isNonNullable } from '~/utils';
+import { communityLinkedObject } from '~/utils/linkedObject/communityLinkedObject';
+import { convertEventPayload } from '~/utils/event';
 
 export class TrendingCommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -81,6 +85,10 @@ export class TrendingCommunityLiveCollectionController extends LiveCollectionCon
       { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnMemberCountChanged },
       { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
       { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      {
+        fn: convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
+        action: EnumCommunityActions.OnCommunityUpdated,
+      },
     ]);
   }
 
@@ -94,7 +102,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/getTrendingCommunities/TrendingCommunitiesPaginationController.ts

@@ -11,7 +11,11 @@ export class TrendingCommunitiesPaginationController extends PaginationControlle
   Amity.TrendingCommunityLiveCollection
 > {
   async getRequest(queryParams: Amity.TrendingCommunityLiveCollection, token: string | undefined) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const {
+      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
+      includeDiscoverablePrivateCommunity,
+      ...params
+    } = queryParams;
     const options = token ? { token } : { limit };
 
     const { data: queryResponse } = await this.http.get<Amity.CommunityPayload & Amity.Pagination>(
@@ -20,6 +24,7 @@ export class TrendingCommunitiesPaginationController extends PaginationControlle
         params: {
           ...params,
           options,
+          includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
         },
       },
     );

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

@@ -64,7 +64,7 @@ export class TrendingCommunitiesQueryStreamController extends QueryStreamControl
   }
 
   reactor(action: EnumCommunityActions | EnumCommunityMemberActions) {
-    return (community: Amity.Community) => {
+    return (community: Amity.InternalCommunity) => {
       const collection = pullFromCache<Amity.TrendingCommunityLiveCollectionCache>(
         this.cacheKey,
       )?.data;
@@ -77,7 +77,7 @@ export class TrendingCommunitiesQueryStreamController extends QueryStreamControl
 
   subscribeRTE(
     createSubscriber: {
-      fn: (reactor: (channel: Amity.Community) => void) => Amity.Unsubscriber;
+      fn: (reactor: (channel: Amity.InternalCommunity) => void) => Amity.Unsubscriber;
       action: EnumCommunityActions | EnumCommunityMemberActions;
     }[],
   ) {

package/src/communityRepository/observers/index.ts

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

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

@@ -15,8 +15,10 @@ import {
   onCommunityLeft,
   onLocalCommunityLeft,
   onCommunityUserChanged,
+  onLocalCommunityJoin,
 } from '~/communityRepository/communityMembership';
 import { isNonNullable } from '~/utils';
+import { convertEventPayload } from '~/utils/event';
 
 export class SearchCommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -81,6 +83,10 @@ export class SearchCommunityLiveCollectionController extends LiveCollectionContr
       { 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/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/observers/searchCommunities/SearchCommunitiesQueryStreamController.ts

@@ -60,7 +60,7 @@ export class CommunitiesQueryStreamController extends QueryStreamController<
   }
 
   reactor(action: EnumCommunityActions | EnumCommunityMemberActions) {
-    return (community: Amity.Community) => {
+    return (community: Amity.InternalCommunity) => {
       const collection = pullFromCache<Amity.SearchCommunityLiveCollectionCache>(
         this.cacheKey,
       )?.data;
@@ -73,7 +73,7 @@ export class CommunitiesQueryStreamController extends QueryStreamController<
 
   subscribeRTE(
     createSubscriber: {
-      fn: (reactor: (channel: Amity.Community) => void) => Amity.Unsubscriber;
+      fn: (reactor: (channel: Amity.InternalCommunity) => void) => Amity.Unsubscriber;
       action: EnumCommunityActions | EnumCommunityMemberActions;
     }[],
   ) {

package/src/communityRepository/observers/semanticSearch/SemanticSearchCommunityLiveCollectionController.ts

@@ -15,6 +15,7 @@ import {
   onLocalCommunityJoined,
   onLocalCommunityLeft,
   onCommunityUserChanged,
+  onLocalCommunityJoin,
 } from '~/communityRepository/communityMembership';
 
 import { isNonNullable } from '~/utils';
@@ -24,6 +25,7 @@ import { prepareSemanticSearchCommunityPayload } from '~/communityRepository/uti
 import { getActiveClient } from '~/client';
 import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
 import { filterByCommunityMembership } from '~/core/query';
+import { convertEventPayload } from '~/utils/event';
 
 export class SemanticSearchCommunityLiveCollectionController extends LiveCollectionController<
   'semanticSearchCommunity',
@@ -94,6 +96,10 @@ export class SemanticSearchCommunityLiveCollectionController extends LiveCollect
       { 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/semanticSearch/SemanticSearchCommunityPaginationController.ts

@@ -29,6 +29,7 @@ export class SemanticSearchCommunityPaginationController extends PaginationContr
         ...params,
         filter: communityMembershipStatus ?? AmityCommunityMemberStatusFilter.ALL,
         options,
+        includeDiscoverablePrivateCommunity: params.includeDiscoverablePrivateCommunity ?? true,
       },
     });
     return queryResponse;

package/src/communityRepository/observers/semanticSearch/SemanticSearchCommunityQueryStreamController.ts

@@ -63,7 +63,7 @@ export class SemanticSearchCommunityQueryStreamController extends QueryStreamCon
   }
 
   reactor(action: EnumCommunityActions | EnumCommunityMemberActions) {
-    return (community: Amity.Community) => {
+    return (community: Amity.InternalCommunity) => {
       const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
       if (!collection) return;
 
@@ -77,7 +77,7 @@ export class SemanticSearchCommunityQueryStreamController extends QueryStreamCon
 
   subscribeRTE(
     createSubscriber: {
-      fn: (reactor: (community: Amity.Community) => void) => Amity.Unsubscriber;
+      fn: (reactor: (community: Amity.InternalCommunity) => void) => Amity.Unsubscriber;
       action: EnumCommunityActions | EnumCommunityMemberActions;
     }[],
   ) {

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
@@ -12,7 +12,7 @@ function isMember(membership: Amity.Membership<'community'>['communityMembership
  * checks if currently logged in user is part of the community
  */
 function isCurrentUserPartOfCommunity(
-  c: Amity.Community,
+  c: Amity.InternalCommunity,
   m: Amity.Membership<'community'>,
 ): boolean {
   const { userId } = getActiveUser();
@@ -28,11 +28,15 @@ function isCurrentUserPartOfCommunity(
  * Althought this can be calculated, it's not scalable.
  */
 export function updateMembershipStatus(
-  communities: Amity.Community[],
+  communities: Amity.RawCommunity[],
   communityUsers: Amity.Membership<'community'>[],
-): Amity.Community[] {
+): Amity.InternalCommunity[] {
   return communities.map(c => {
-    const cachedCommunity = pullFromCache<Amity.Community>(['community', 'get', c.communityId]);
+    const cachedCommunity = pullFromCache<Amity.InternalCommunity>([
+      'community',
+      'get',
+      c.communityId,
+    ]);
     if (cachedCommunity?.data && cachedCommunity?.data.hasOwnProperty('isJoined')) {
       return {
         ...cachedCommunity.data,

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'];
@@ -13,7 +14,7 @@ const getMatchPostSetting = (value: {
   ) ?? DefaultCommunityPostSetting;
 
 export function addPostSetting({ communities }: { communities: Amity.RawCommunity[] }) {
-  return communities.map<Amity.Community>(
+  return communities.map<Amity.InternalCommunity>(
     ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
       postSetting: getMatchPostSetting({
         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/liveCollection/PaginationController.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 
 export abstract class PaginationController<
   TPayloadDomain extends keyof Amity.Payloads,

package/src/core/liveCollection/PaginationNoPageController.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 
 export abstract class PaginationNoPageController<
   TPayloadDomain extends keyof Amity.Payloads,

package/src/core/model/idResolvers.ts

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

package/src/core/model/index.ts

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

package/src/index.ts

@@ -51,3 +51,5 @@ export * as AdRepository from './adRepository';
 export * from './external/api';
 
 export * as notificationTray from './notificationTray';
+
+export * as InvitationRepository from './invitationRepository';

package/src/invitationRepository/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onLocalInvitationCreated';
+export * from './onLocalInvitationUpdated';
+export * from './onLocalInvitationDeleted';

package/src/invitationRepository/events/onLocalInvitationCreated.ts

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