@amityco/ts-sdk 7.4.1-b7aa4210.0 → 7.4.1-bf4803ea.0

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

@@ -27,6 +27,9 @@ declare global {
       semanticSearchPost: Amity.SemanticSearchPostPayload;
       semanticSearchCommunity: Amity.SemanticSearchCommunityPayload;
       notificationTrayItem: Amity.NotificationTrayPayload;
+      invitation: Amity.InvitationPayload;
+      myInvitation: Amity.MyInvitationsPayload;
+      joinRequest: Amity.CommunityJoinRequestPayload;
     };
 
     type UserPayload = {
@@ -225,7 +228,7 @@ declare global {
     type SubChannelPayload<T extends Amity.MessageContentType = any> = {
       messageFeeds: Amity.RawSubChannel[];
       messages: Amity.RawMessage<T>[];
-      users: Amity.InternalUser[];
+      users: Amity.RawUser[];
       files: Amity.File[];
     };
 
@@ -297,6 +300,12 @@ declare global {
       files: Amity.File[];
     };
 
+    type CommunityJoinRequestPayload = {
+      joinRequests: Amity.RawJoinRequest[];
+      users: Amity.RawUser[];
+      files: Amity.File[];
+    };
+
     type RecommendedCommunityPayload = Amity.CommunityPayload;
     type TrendingCommunityPayload = Amity.CommunityPayload;
 
@@ -306,8 +315,18 @@ declare global {
      * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
      */
     type ProcessedCommunityPayload = Omit<CommunityPayload, 'communities' | 'communityUsers'> & {
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
       communityUsers: Amity.Membership<'community'>[];
+      users: Amity.InternalUser[];
+    };
+
+    type ProcessedJoinRequestPayload = Omit<
+      CommunityJoinRequestPayload,
+      'communities' | 'communityUsers' | 'joinRequests' | 'users'
+    > & {
+      joinRequests: Amity.InternalJoinRequest[];
+      files: Amity.File[];
+      users: Amity.InternalUser[];
     };
 
     type CategoryPayload = {
@@ -333,7 +352,7 @@ declare global {
       CommunityMembershipPayload,
       'communities' | 'communityUsers'
     > & {
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
       communityUsers: Amity.Membership<'community'>[];
     };
 
@@ -383,7 +402,7 @@ declare global {
       Amity.StoryTargetPayload;
 
     type ProcessedGlobalStoryFeed = Omit<GlobalStoryFeedPayload, 'communities'> & {
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
     };
 
     // Original Payload form BE
@@ -436,7 +455,7 @@ declare global {
      */
     type ProcessedPostPayload = Omit<PostPayload, 'communities' | 'communityUsers' | 'posts'> & {
       posts: Amity.InternalPost[];
-      communities: Amity.Community[];
+      communities: Amity.InternalCommunity[];
       communityUsers: Amity.Membership<'community'>[];
     };
 
@@ -545,5 +564,29 @@ declare global {
       Amity.Flaggable &
       Amity.Taggable &
       Amity.Timestamps;
+
+    type InvitationPayload = {
+      invitations: Amity.RawInvitation[];
+      users: Amity.RawUser[];
+    };
+
+    type ProcessedInvitationPayload = {
+      invitations: Amity.InternalInvitation[];
+      users: Amity.InternalUser[];
+    };
+
+    type MyInvitationsPayload = {
+      invitations: Amity.RawInvitation[];
+      users: Amity.RawUser[];
+    };
+
+    type ProcessedMyInvitationsPayload = {
+      invitations: Amity.InternalInvitation[];
+      users: Amity.InternalUser[];
+    };
+
+    type JoinRequestPayload = {
+      joinRequests: Amity.RawJoinRequest[];
+    };
   }
 }

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

@@ -1,10 +1,17 @@
 import { AxiosInstance } from 'axios';
 import { Emitter } from 'mitt';
 
+export const enum MembershipAcceptanceTypeEnum {
+  AUTOMATIC = 'automatic',
+  INVITATION = 'invitation',
+}
+
 declare global {
   namespace Amity {
     type Logger = (topic: string, ...args: any[]) => void;
 
+    type MembershipAcceptanceType = MembershipAcceptanceTypeEnum;
+
     const enum TokenTerminationReason {
       GLOBAL_BAN = 'globalBan',
       USER_DELETED = 'userDeleted',
@@ -124,7 +131,12 @@ declare global {
         showMyPost: boolean;
         showOnlyMyFeed: boolean;
       };
+      story: {
+        allowAllUserToCreateStory: boolean;
+        expiryTimeMinutes: number;
+      };
       userPrivacySetting: 'public' | 'private';
+      membershipAcceptance: Amity.MembershipAcceptanceType;
     };
 
     type ConnectClientParams = {

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

@@ -95,17 +95,25 @@ declare global {
       hasFlaggedPost: boolean;
 
       allowCommentInStory?: boolean;
+
+      isDiscoverable?: boolean;
+      requiresJoinApproval?: boolean;
     } & Amity.Taggable &
       Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete &
       Amity.Subscribable;
 
-    type Community = Omit<Amity.RawCommunity, 'onlyAdminCanPost' | 'needApprovalOnPostCreation'> &
+    type InternalCommunity = Omit<
+      Amity.RawCommunity,
+      'onlyAdminCanPost' | 'needApprovalOnPostCreation'
+    > &
       Amity.CommunityStorySettings & {
         postSetting?: ValueOf<typeof CommunityPostSettings>;
       };
 
+    type Community = Amity.InternalCommunity & Amity.CommunityLinkedObject;
+
     type QueryCommunities = {
       membership?: 'all' | 'member' | 'notMember';
       categoryId?: Amity.InternalCategory['categoryId'];
@@ -116,6 +124,16 @@ declare global {
       limit?: number;
     };
 
+    type QueryJoinCommunity = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+    };
+
     type SearchQueryCommunities = {
       displayName?: string;
       membership?: 'all' | 'member' | 'notMember';
@@ -125,6 +143,30 @@ declare global {
       sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
       page?: string;
       limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    };
+
+    type QueryJoinRequest = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      targetType: 'community';
+      type: Amity.JoinRequestType;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
+      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'>>;
@@ -132,6 +174,10 @@ declare global {
     type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
     type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
 
+    type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
+
+    type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
+
     type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
       Omit<SearchQueryCommunities, 'page'>
     >;
@@ -149,6 +195,16 @@ declare global {
       Pick<SearchQueryCommunities, 'page'>
     >;
 
+    type JoinRequestLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequest, 'page'>
+    >;
+
+    type JoinRequestListLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.JoinRequest['joinRequestId'],
+      Pick<QueryJoinRequestList, 'page'>
+    >;
+
     type QueryCommunityMembers = {
       communityId: string;
       memberships?: ('banned' | 'member')[];
@@ -197,6 +253,7 @@ declare global {
         token?: string;
       };
       tags?: string[];
+      includeDiscoverablePrivateCommunity?: boolean;
     };
 
     type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<
@@ -209,5 +266,20 @@ declare global {
       Amity.Community['communityId'], // communityId:score
       QuerySemanticSearchCommunity
     >;
+
+    type CommunityLinkedObject = {
+      createInvitations: (userIds: string[]) => Promise<void>;
+      getMemberInvitations: (
+        params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
+        callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+      ) => Amity.Unsubscriber;
+      getInvitation: () => Promise<Amity.Invitation | undefined>;
+      join: () => Promise<Amity.JoinResult>;
+      getJoinRequests: (
+        params: QueryJoinRequest,
+        callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+      ) => Amity.Unsubscriber;
+      getMyJoinRequest: () => Promise<Amity.JoinRequest | undefined>;
+    };
   }
 }

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

@@ -0,0 +1,116 @@
+export {};
+
+export const enum InvitationTypeEnum {
+  CommunityMemberInvite = 'communityMemberInvite',
+  LivestreamInvite = 'livestreamInvite',
+}
+
+export const enum InvitationStatusEnum {
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Cancelled = 'cancelled',
+}
+
+export const enum InvitationSortByEnum {
+  FirstCreated = 'firstCreated',
+  LastCreated = 'lastCreated',
+}
+
+declare global {
+  namespace Amity {
+    type InvitationType = InvitationTypeEnum;
+
+    type InvitationStatus = InvitationStatusEnum;
+
+    type InvitationTargetType = Extract<Amity.Domain, 'community'>;
+
+    type InvitationTargetMap = {
+      community: Amity.InternalCommunity;
+    };
+
+    type InvitationTarget<T extends InvitationTargetType> = InvitationTargetMap[T];
+
+    type InvitationSortBy = InvitationSortByEnum;
+
+    type RawInvitation = {
+      _id: string;
+      networkId: string;
+      type: Amity.InvitationType;
+      targetId: string;
+      targetType: Amity.InvitationTargetType;
+      userId: string;
+      status: Amity.InvitationStatus;
+      respondedAt: Amity.timestamp;
+      createdBy: string;
+      invitationId: string;
+      invitedUserId: string;
+      invitedUserInternalId: string;
+      invitedUserPublicId: string;
+      inviterUserId: string;
+      inviterUserInternalId: string;
+      inviterUserPublicId: string;
+    } & Amity.Timestamps;
+
+    type InternalInvitation = Omit<RawInvitation, 'createdBy'> & {
+      createdById: string;
+    };
+
+    type Invitation = Omit<Amity.InternalInvitation, 'createdBy'> &
+      Amity.InvitationLinkedObject & {
+        user?: Amity.User;
+        createdById: string;
+        createdBy?: Amity.User;
+        target?: Amity.InvitationTarget<Amity.InvitationTargetType>;
+      };
+
+    type QueryInvitations = {
+      targetId: string;
+      statuses?: string[];
+      token?: Amity.Token;
+      type: Amity.InvitationType;
+      sortBy?: Amity.InvitationSortBy;
+      limit?: Amity.PageLimit['limit'];
+      targetType: Amity.InvitationTargetType;
+    };
+
+    type InvitationLiveCollection = Amity.LiveCollectionParams<Omit<QueryInvitations, 'limit'>>;
+
+    type InvitationLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryInvitations, 'limit'>
+    >;
+
+    type QueryMyInvitations = {
+      targetId?: string;
+      token?: Amity.Token;
+      type?: Amity.InvitationType;
+      sortBy?: Amity.InvitationSortBy;
+      limit?: Amity.PageLimit['limit'];
+      statuses?: InvitationStatusEnum[];
+      targetType?: Amity.InvitationTargetType;
+    };
+
+    type MyInvitationsLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryMyInvitations, 'limit'>
+    >;
+
+    type MyInvitationsLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryMyInvitations, 'limit'>
+    >;
+
+    type InvitationLinkedObject = {
+      accept: () => Promise<void>;
+      reject: () => Promise<void>;
+      cancel: () => Promise<void>;
+    };
+
+    type CreateInvitations = {
+      type: Amity.InvitationType;
+      targetType: Amity.InvitationTargetType;
+      targetId: string;
+      userIds: string[];
+    };
+  }
+}

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

@@ -0,0 +1,66 @@
+export {};
+
+export const enum JoinRequestStatusEnum {
+  Pending = 'pending',
+  Approved = 'approved',
+  Rejected = 'rejected',
+  Cancelled = 'cancelled',
+}
+
+export const enum JoinResultStatusEnum {
+  Success = 'success',
+  Pending = 'pending',
+}
+
+declare global {
+  namespace Amity {
+    type JoinRequestStatus = JoinRequestStatusEnum;
+
+    type JoinResultStatus = JoinResultStatusEnum;
+
+    type JoinRequestType = 'communityJoinRequest';
+
+    type JoinResult = {
+      status: Amity.JoinResultStatus;
+      request?: Amity.JoinRequest;
+    };
+
+    type RawJoinRequest = {
+      _id: string;
+      createdAt: Amity.timestamp;
+      joinRequestId: string;
+      networkId: string;
+
+      requestorId: string;
+      requestorInternalId: string;
+      requestorPublicId: string;
+
+      respondedAt: Amity.timestamp | null;
+      responderId: string | null;
+      responderInternalId: string | null;
+      responderPublicId: string | null;
+
+      status: Amity.JoinRequestStatus;
+      targetId: string;
+      targetType: string;
+      type: Amity.JoinRequestType;
+      updatedAt: Amity.timestamp;
+      userId: string;
+    };
+
+    type InternalJoinRequest = Omit<RawJoinRequest, '_id'>;
+
+    type JoinRequest = Omit<Amity.InternalJoinRequest, 'responderId'> &
+      Amity.JoinRequestLinkedObject & {
+        user?: Amity.User;
+        feeds?: Amity.Feed[];
+        files?: Amity.File[];
+      };
+
+    type JoinRequestLinkedObject = {
+      cancel: () => Promise<void>;
+      approve: () => Promise<void>;
+      reject: () => Promise<void>;
+    };
+  }
+}

package/src/@types/index.ts

@@ -38,3 +38,6 @@ export * from './domains/post';
 export * from './domains/story';
 export * from './domains/ad';
 export * from './domains/notification';
+export * from './domains/client';
+export * from './domains/invitation';
+export * from './domains/joinRequest';

package/src/communityRepository/api/createCommunity.ts

@@ -1,3 +1,4 @@
+import { LinkedObject } from '~/utils/linkedObject';
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
@@ -11,7 +12,7 @@ import { prepareCommunityPayload, prepareCommunityRequest } from '../utils';
 /**
  * ```js
  * import { createCommunity } from '@amityco/ts-sdk'
- * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar' })
+ * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
  * ```
  *
  * Creates an {@link Amity.Community}
@@ -33,6 +34,8 @@ export const createCommunity = async (
     | 'postSetting'
     | 'tags'
     | 'metadata'
+    | 'isDiscoverable'
+    | 'requiresJoinApproval'
   > &
     Amity.CommunityStorySettings & {
       userIds?: string[];
@@ -60,7 +63,7 @@ export const createCommunity = async (
 
   const { communities } = data;
   return {
-    data: communities[0],
+    data: LinkedObject.community(communities[0]),
     cachedAt,
   };
 };

package/src/communityRepository/api/getCommunities.ts

@@ -5,6 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -22,15 +23,21 @@ import { prepareCommunityPayload } from '../utils';
  */
 export const getCommunities = async (
   communityIds: Amity.Community['communityId'][],
+  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.Community[]>> => {
   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 },
+      params: {
+        communityIds: encodedCommunityIds,
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+      },
     },
   );
 
@@ -43,7 +50,7 @@ export const getCommunities = async (
   }
 
   return {
-    data: data.communities,
+    data: data.communities.map(community => LinkedObject.community(community)),
     cachedAt,
   };
 };

package/src/communityRepository/api/getCommunity.ts

@@ -5,6 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -22,6 +23,8 @@ import { prepareCommunityPayload } from '../utils';
  */
 export const getCommunity = async (
   communityId: Amity.Community['communityId'],
+  type?: Amity.JoinRequestType,
+  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.Community>> => {
   const client = getActiveClient();
   client.log('community/getCommunity', communityId);
@@ -29,6 +32,12 @@ export const getCommunity = async (
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
+    {
+      params: {
+        type: 'communityJoinRequest',
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+      },
+    },
   );
 
   const data = prepareCommunityPayload(payload);
@@ -42,7 +51,9 @@ export const getCommunity = async (
   const { communities } = data;
 
   return {
-    data: communities.find(community => community.communityId === communityId)!,
+    data: LinkedObject.community(
+      communities.find(community => community.communityId === communityId)!,
+    ),
     cachedAt,
   };
 };
@@ -73,7 +84,7 @@ getCommunity.locally = (
   if (!cached) return;
 
   return {
-    data: cached.data,
+    data: LinkedObject.community(cached.data),
     cachedAt: cached.cachedAt,
   };
 };

package/src/communityRepository/api/getRecommendedCommunities.ts

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareCommunityPayload } from '../utils';
 import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: community.query.recommended_communities
@@ -24,18 +25,24 @@ import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
  * @private
  */
 export const getRecommendedCommunities = async (
-  query?: Amity.PageLimit,
+  query?: Amity.PageLimit & { includeDiscoverablePrivateCommunity?: boolean },
 ): Promise<Amity.Cached<Amity.Community[]>> => {
   const client = getActiveClient();
   client.log('community/getRecommendedCommunities', query);
 
-  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = query ?? {};
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDiscoverablePrivateCommunity } =
+    query ?? {};
 
   // API-FIX: backend doesnt answer Amity.Response
   // const { data: payload } = await client.http.get<Amity.Response<CommunityPayload>>(
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/recommended`,
-    { params: { options: { limit } } },
+    {
+      params: {
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+        options: { limit },
+      },
+    },
   );
 
   const data = prepareCommunityPayload(payload);
@@ -47,5 +54,5 @@ export const getRecommendedCommunities = async (
     ingestInCache(data, { cachedAt });
   }
 
-  return { data: communities, cachedAt };
+  return { data: communities.map(community => LinkedObject.community(community)), cachedAt };
 };

package/src/communityRepository/api/getTrendingCommunities.ts

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareCommunityPayload } from '../utils';
 import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -21,18 +22,24 @@ import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
  * @private
  */
 export const getTrendingCommunities = async (
-  query?: Amity.PageLimit,
+  query?: Amity.PageLimit & { includeDiscoverablePrivateCommunity?: boolean },
 ): Promise<Amity.Cached<Amity.Community[]>> => {
   const client = getActiveClient();
   client.log('community/getTrendingCommunities', query);
 
-  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = query ?? {};
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDiscoverablePrivateCommunity } =
+    query ?? {};
 
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/top-trending`,
-    { params: { options: { limit } } },
+    {
+      params: {
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+        options: { limit },
+      },
+    },
   );
 
   const data = prepareCommunityPayload(payload);
@@ -44,5 +51,5 @@ export const getTrendingCommunities = async (
     ingestInCache(data, { cachedAt });
   }
 
-  return { data: communities, cachedAt };
+  return { data: communities.map(community => LinkedObject.community(community)), cachedAt };
 };

package/src/communityRepository/api/joinCommunity.ts

@@ -1,9 +1,12 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareCommunityPayload } from '~/communityRepository/utils';
 import { fireEvent } from '~/core/events';
 
+/**
+ * @deprecated This function will to be deprecated and use the new community.join().
+ */
 /* begin_public_function
   id: community.join
 */