@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

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

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

@@ -0,0 +1,49 @@
+import { fireEvent } from '~/core/events';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api/activeClient';
+import { JoinRequestStatusEnum } from '~/@types';
+
+/* 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) {
+    upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+      status: JoinRequestStatusEnum.Cancelled,
+    });
+
+    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 */

package/src/communityRepository/observers/getCommunities/CommunitiesLiveCollectionController.ts

@@ -0,0 +1,162 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CommunitiesPaginationController } from './CommunitiesPaginationController';
+import { CommunitiesQueryStreamController } from './CommunitiesQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommunityCreated,
+  onCommunityDeleted,
+  onCommunityUpdated,
+} from '~/communityRepository/events';
+import {
+  filterByCommunityMembership,
+  filterByPropEquality,
+  sortByDisplayName,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+import { getActiveClient } from '~/client';
+import { EnumCommunityActions } from './enums';
+import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onLocalCommunityJoined,
+  onLocalCommunityLeft,
+  onCommunityUserChanged,
+  onLocalCommunityJoin,
+} from '~/communityRepository/communityMembership';
+import { isNonNullable } from '~/utils';
+import { convertEventPayload } from '~/utils/event';
+import { communityLinkedObject } from '~/utils/linkedObject/communityLinkedObject';
+
+export class CommunityLiveCollectionController extends LiveCollectionController<
+  'community',
+  Amity.CommunityLiveCollection,
+  Amity.Community,
+  CommunitiesPaginationController
+> {
+  private queryStreamController: CommunitiesQueryStreamController;
+
+  private query: Amity.CommunityLiveCollection;
+
+  constructor(
+    query: Amity.CommunityLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Community>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['community', 'collection', queryStreamId];
+    const paginationController = new CommunitiesPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CommunitiesQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommunityPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'community'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommunityCreated, action: EnumCommunityActions.OnCommunityCreated },
+      { fn: onCommunityDeleted, action: EnumCommunityActions.OnCommunityDeleted },
+      { fn: onCommunityUpdated, action: EnumCommunityActions.OnCommunityUpdated },
+      { fn: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnMemberCountChanged },
+      { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      {
+        fn: convertEventPayload(onLocalCommunityJoin, 'targetId', 'community'),
+        action: EnumCommunityActions.OnCommunityUpdated,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data =
+      collection.data
+        .map(id => pullFromCache<Amity.Community>(['community', 'get', id]))
+        .filter(isNonNullable)
+        .map(({ data }) => communityLinkedObject(data)) ?? [];
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Community[]) {
+    const { userId } = getActiveClient();
+
+    let communities = data;
+
+    if (!this.query.includeDeleted) {
+      communities = filterByPropEquality(communities, 'isDeleted', false);
+    }
+
+    if (this.query.categoryId) {
+      communities = communities.filter(c => c.categoryIds?.includes(this.query.categoryId!));
+    }
+
+    if (this.query.tags) {
+      communities = communities.filter(c => c.tags?.some(t => this.query.tags?.includes(t)));
+    }
+
+    if (this.query.membership && userId) {
+      communities = filterByCommunityMembership(communities, this.query.membership, userId);
+    }
+
+    const sortFn = (() => {
+      switch (this.query.sortBy) {
+        case 'firstCreated':
+          return sortByFirstCreated;
+        case 'lastCreated':
+          return sortByLastCreated;
+        default:
+          return sortByLastCreated;
+      }
+    })();
+
+    communities = communities.sort(sortFn);
+
+    return communities;
+  }
+}

package/src/communityRepository/observers/getCommunities/CommunitiesPaginationController.ts

@@ -0,0 +1,31 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class CommunitiesPaginationController extends PaginationController<
+  'community',
+  Amity.CommunityLiveCollection
+> {
+  async getRequest(queryParams: Amity.CommunityLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.CommunityPayload & Amity.Pagination>(
+      `/api/v3/communities`,
+      {
+        params: {
+          ...params,
+          isDeleted: inferIsDeleted(params.includeDeleted),
+          filter: params.membership,
+          includeDiscoverablePrivateCommunity: params.includeDiscoverablePrivateCommunity ?? true,
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/communityRepository/observers/getCommunities/CommunitiesQueryStreamController.ts

@@ -0,0 +1,85 @@
+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';
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
+import { EnumCommunityActions } from './enums';
+import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
+
+export class CommunitiesQueryStreamController extends QueryStreamController<
+  Amity.CommunityPayload,
+  Amity.CommunityLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.CommunityPayload) => Amity.ProcessedCommunityPayload;
+
+  constructor(
+    query: Amity.CommunityLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.CommunityPayload) => Amity.ProcessedCommunityPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommunityPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+      saveCommunityUsers(response.communities, response.communityUsers);
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommunityPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.communities.map(getResolver('community')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const communities = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...communities, ...response.communities.map(getResolver('community'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumCommunityActions | EnumCommunityMemberActions) {
+    return (community: Amity.InternalCommunity) => {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      /*
+       * Simply update a collection and let responder decide what to do with data
+       */
+      collection.data = [...new Set([community.communityId, ...collection.data])];
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (channel: Amity.InternalCommunity) => void) => Amity.Unsubscriber;
+      action: EnumCommunityActions | EnumCommunityMemberActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

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

@@ -0,0 +1,5 @@
+export enum EnumCommunityActions {
+  OnCommunityCreated = 'onCommunityCreated',
+  OnCommunityDeleted = 'onCommunityDeleted',
+  OnCommunityUpdated = 'onCommunityUpdated',
+}