@amityco/ts-sdk 7.4.1-d23fab2f.0 → 7.4.1-fd0f791a.0

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

@@ -12,13 +12,26 @@ export const enum InvitationStatusEnum {
   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' | 'post' | 'comment'>;
+    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;
@@ -30,11 +43,62 @@ declare global {
       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 = RawInvitation;
+    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 Invitation = Amity.InternalInvitation & Amity.InvitationLinkedObject;
+    type MyInvitationsLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.InternalInvitation['_id'],
+      Pick<QueryMyInvitations, 'limit'>
+    >;
 
     type InvitationLinkedObject = {
       accept: () => Promise<void>;

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

@@ -40,3 +40,4 @@ export * from './domains/ad';
 export * from './domains/notification';
 export * from './domains/client';
 export * from './domains/invitation';
+export * from './domains/joinRequest';

package/src/communityRepository/api/getCommunities.ts

@@ -23,6 +23,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  */
 export const getCommunities = async (
   communityIds: Amity.Community['communityId'][],
+  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.Community[]>> => {
   const client = getActiveClient();
   client.log('community/getCommunities', communityIds);
@@ -31,7 +32,10 @@ export const getCommunities = async (
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/list`,
     {
-      params: { communityIds },
+      params: {
+        communityIds,
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+      },
     },
   );
 

package/src/communityRepository/api/getCommunity.ts

@@ -23,6 +23,8 @@ import { LinkedObject } from '~/utils/linkedObject';
  */
 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);
@@ -30,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);
@@ -76,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

@@ -25,18 +25,24 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @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);

package/src/communityRepository/api/getTrendingCommunities.ts

@@ -22,18 +22,24 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @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);

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
 */

package/src/communityRepository/api/updateCommunity.ts

@@ -13,7 +13,7 @@ import { LinkedObject } from '~/utils/linkedObject';
 /**
  * ```js
  * import { updateCommunity } from '@amityco/ts-sdk'
- * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
  * ```
  *
  * Updates an {@link Amity.Community}
@@ -29,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>> => {

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,51 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+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 });
+
+  fireEvent('local.community.join', data.joinRequests);
+
+  const status =
+    data.joinRequests[0].status === JoinRequestStatusEnum.Approved
+      ? JoinResultStatusEnum.Success
+      : JoinResultStatusEnum.Pending;
+
+  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 */

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

@@ -0,0 +1,46 @@
+import { fireEvent } from '~/core/events';
+import { dropFromCache, pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+
+/* begin_public_function
+  id: joinRequest.cancel
+*/
+/**
+ * ```js
+ * import { joinRequest } from '@amityco/ts-sdk'
+ * const isCanceled = await joinRequest.cancel()
+ * ```
+ *
+ * Cancels a {@link Amity.JoinRequest} object
+ *
+ * @param joinRequest the {@link Amity.JoinRequest} to cancel
+ * @returns A success boolean if the {@link Amity.JoinRequest} was canceled
+ *
+ * @category Join Request API
+ * @async
+ */
+export const cancelJoinRequest = async (
+  joinRequest: Amity.InternalJoinRequest,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('joinRequest/cancelJoinRequest', joinRequest.joinRequestId);
+
+  const { data } = await client.http.delete<{ success: boolean }>(
+    `/api/v4/communities/${joinRequest.targetId}/join`,
+  );
+
+  const joinRequestCache = pullFromCache<Amity.InternalJoinRequest>([
+    'joinRequest',
+    'get',
+    joinRequest.joinRequestId,
+  ])?.data;
+
+  if (joinRequestCache) {
+    dropFromCache(['joinRequest', 'get', joinRequest.joinRequestId]);
+
+    fireEvent('local.joinRequest.deleted', [joinRequestCache]);
+  }
+
+  return data.success;
+};
+/* end_public_function */

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

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