@amityco/ts-sdk-react-native 7.5.3 → 7.6.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/channel.ts

@@ -93,6 +93,7 @@ declare global {
     type Channel<T extends ChannelType = any> = InternalChannel<T> & {
       messagePreview?: Amity.MessagePreview | null;
       markAsRead: () => Promise<boolean>;
+      previewMembers: Amity.Membership<'channel'>[];
     };
 
     type QueryChannels = {

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',
@@ -138,7 +145,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'];
@@ -114,6 +122,17 @@ declare global {
       sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
       page?: string;
       limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    };
+
+    type QueryJoinCommunity = {
+      communityId: string;
+      status: Amity.JoinRequestStatus;
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
+      options?: {
+        limit?: number;
+        token?: string;
+      };
     };
 
     type SearchQueryCommunities = {
@@ -125,12 +144,46 @@ 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'>>;
 
-    type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
-    type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
+    type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{
+      limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    }>;
+    type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{
+      limit?: number;
+      includeDiscoverablePrivateCommunity?: boolean;
+    }>;
+
+    type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
+
+    type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
 
     type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
       Omit<SearchQueryCommunities, 'page'>
@@ -149,6 +202,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 +260,7 @@ declare global {
         token?: string;
       };
       tags?: string[];
+      includeDiscoverablePrivateCommunity?: boolean;
     };
 
     type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<
@@ -209,5 +273,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/content.ts

@@ -24,7 +24,15 @@ declare global {
       | Exclude<`${ContentFlagReasonEnum}`, `${ContentFlagReasonEnum.Others}`>
       | (string & {});
 
-    type ContentType = 'text' | 'image' | 'file' | 'video' | 'poll' | 'json' | string;
+    type ContentType =
+      | 'text'
+      | 'image'
+      | 'file'
+      | 'video'
+      | 'poll'
+      | 'json'
+      | 'liveStream'
+      | string;
 
     type ContentFeedType = ValueOf<typeof ContentFeedType>;
 
@@ -58,6 +66,10 @@ declare global {
       pollId: Amity.Poll['pollId'];
     };
 
+    type ContentDataStream = {
+      streamId: Amity.Stream['streamId'];
+    };
+
     type ContentData<T extends ContentType> = T extends 'text'
       ? ContentDataText
       : T extends 'file'
@@ -68,6 +80,8 @@ declare global {
       ? ContentDataVideo
       : T extends 'poll'
       ? ContentDataPoll
+      : T extends 'liveStream'
+      ? ContentDataStream
       : T extends 'json'
       ? Record<string, unknown>
       : T extends string

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

@@ -15,6 +15,8 @@ declare global {
 
     type Member<T extends Amity.GroupType> = {
       userId: Amity.InternalUser['userId'];
+      userInternalId: Amity.InternalUser['userInternalId'];
+      userPublicId: Amity.InternalUser['userPublicId'];
     } & (T extends 'channel'
       ? {
           channelId: Amity.Channel['channelId'];

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

@@ -0,0 +1,119 @@
+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 InvitationDomain<T extends Amity.InvitationTargetType = Amity.InvitationTargetType> =
+      T extends 'community' ? { communityId: string } : { communityId?: string };
+
+    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 &
+      Amity.InvitationDomain<Amity.InvitationTargetType>;
+
+    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>;
+    };
+
+    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/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/@types/domains/pinnedPost.ts

@@ -32,6 +32,6 @@ declare global {
       pinnedAt: Date;
     };
 
-    type GlobalPinnedPostLiveCollection = Amity.LiveCollectionParams<Record<string, never>>;
+    type GlobalPinnedPostLiveCollection = Amity.LiveCollectionParams<{}>;
   }
 }

package/src/@types/index.ts

@@ -38,3 +38,8 @@ 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';
+export * from './domains/pin';
+export * from './domains/pinnedPost';

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -23,6 +23,7 @@ import {
 } from '~/core/query';
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -100,7 +101,8 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       collection.data
         .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [],
+        .map(({ data }) => data)
+        .map(LinkedObject.channelMember) ?? [],
     );
 
     if (!this.shouldNotify(data) && origin === 'event') return;

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberLiveCollectionController.ts

@@ -17,6 +17,7 @@ import {
 import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
+import { LinkedObject } from '~/utils/linkedObject';
 
 export class SearchChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -94,7 +95,7 @@ export class SearchChannelMemberLiveCollectionController extends LiveCollectionC
       collection.data
         .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [],
+        .map(({ data }) => LinkedObject.channelMember(data) ?? []),
     );
 
     if (!this.shouldNotify(data) && origin === 'event') return;

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberQueryStreamController.ts

@@ -72,7 +72,7 @@ export class SearchChannelMemberQueryStreamController extends QueryStreamControl
   }
 
   reactor(action: string) {
-    return (channel: Amity.InternalChannel, channelMember: Amity.Membership<'channel'>) => {
+    return (channel: Amity.StaticInternalChannel, channelMember: Amity.Membership<'channel'>) => {
       if (this.query.channelId !== channelMember.channelId) return;
 
       const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
@@ -100,7 +100,7 @@ export class SearchChannelMemberQueryStreamController extends QueryStreamControl
     createSubscriber: {
       fn: (
         reactor: (
-          channel: Amity.InternalChannel,
+          channel: Amity.StaticInternalChannel,
           channelMember: Amity.Membership<'channel'>,
         ) => void,
       ) => Amity.Unsubscriber;

package/src/client/api/index.ts

@@ -6,6 +6,7 @@ export * from './createClient';
 export * from './login';
 export * from './logout';
 export * from './secureLogout';
+export * from './resumeSession';
 
 export * from './isConnected';