@amityco/ts-sdk-react-native 6.22.1-600ab29.0 → 6.22.1-b0a1854.0

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersLiveCollectionController.ts

@@ -0,0 +1,130 @@
+/* eslint-disable no-use-before-define */
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { SearchCommunityMembersPaginationController } from './SearchCommunityMembersPaginationController';
+import { SearchCommunityMembersQueryStreamController } from './SearchCommunityMembersQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserBanned,
+  onCommunityUserChanged,
+  onCommunityUserRoleRemoved,
+  onCommunityUserUnbanned,
+} from '~/communityRepository/communityMembership/events';
+import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+import { isNonNullable } from '~/utils';
+import { EnumCommunityMemberActions } from './enums';
+
+export class SearchCommunityMembersLiveCollectionController extends LiveCollectionController<
+  'communityUser',
+  Amity.SearchCommunityMemberLiveCollection,
+  Amity.Membership<'community'>,
+  SearchCommunityMembersPaginationController
+> {
+  private queryStreamController: SearchCommunityMembersQueryStreamController;
+
+  private query: Amity.SearchCommunityMemberLiveCollection;
+
+  constructor(
+    query: Amity.SearchCommunityMemberLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Membership<'community'>>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['communityUsers', 'collection', queryStreamId];
+    const paginationController = new SearchCommunityMembersPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new SearchCommunityMembersQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.SearchCommunityMemberLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommunityMembershipPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'communityUser'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
+      { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
+      {
+        fn: onCommunityUserRoleRemoved,
+        action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
+      },
+      { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions.OnCommunityUserUnbanned },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.SearchCommunityMemberLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Membership<'community'>>(['communityUsers', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => 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.Membership<'community'>[]) {
+    let communityMembers = filterByPropIntersection(data, 'roles', this.query.roles);
+
+    if (this.query.memberships) {
+      communityMembers = communityMembers.filter(({ communityMembership }) => {
+        const memberships: Amity.GroupMembership[] = this.query.memberships || [];
+        return memberships.includes(communityMembership);
+      });
+    }
+
+    if (this.query.search) {
+      communityMembers = filterBySearchTerm(communityMembers, this.query.search);
+    }
+
+    return communityMembers;
+  }
+}

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersPaginationController.ts

@@ -0,0 +1,29 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class SearchCommunityMembersPaginationController extends PaginationController<
+  'communityUser',
+  Amity.CommunityMemberLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.SearchCommunityMemberLiveCollection,
+    token: string | undefined,
+  ) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.CommunityMembershipPayload & Amity.Pagination
+    >(`/api/v3/communities/${params.communityId}/users`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersQueryStreamController.ts

@@ -0,0 +1,105 @@
+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 { EnumCommunityMemberActions } from './enums';
+
+export class SearchCommunityMembersQueryStreamController extends QueryStreamController<
+  Amity.CommunityMembershipPayload,
+  Amity.SearchCommunityMemberLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.CommunityMembershipPayload,
+  ) => Amity.ProcessedCommunityMembershipPayload;
+
+  constructor(
+    query: Amity.SearchCommunityMemberLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.CommunityMembershipPayload,
+    ) => Amity.ProcessedCommunityMembershipPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommunityMembershipPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommunityMembershipPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.communityUsers.map(({ communityId, userId }) =>
+          getResolver('communityUsers')({ communityId, userId }),
+        ),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const communityUsers = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...communityUsers,
+            ...response.communityUsers.map(({ communityId, userId }) =>
+              getResolver('communityUsers')({ communityId, userId }),
+            ),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: EnumCommunityMemberActions) {
+    return (community: Amity.Community, communityMembers: Amity.Membership<'community'>[]) => {
+      const collection = pullFromCache<Amity.SearchCommunityMemberLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      communityMembers.forEach(communityMember => {
+        const communityMemberCacheId = getResolver('communityUsers')({
+          communityId: this.query.communityId,
+          userId: communityMember.userId,
+        });
+
+        if (communityMember.communityMembership === 'none') {
+          collection.data = collection.data.filter(m => m !== communityMemberCacheId);
+        }
+      });
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (
+        reactor: (channel: Amity.Community, communityUser: Amity.Membership<'community'>[]) => void,
+      ) => Amity.Unsubscriber;
+      action: EnumCommunityMemberActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/communityRepository/communityMembership/observers/searchMembers/enums.ts

@@ -0,0 +1,9 @@
+export enum EnumCommunityMemberActions {
+  OnCommunityJoined = 'onCommunityJoined',
+  OnCommunityLeft = 'onCommunityLeft',
+  OnCommunityUserBanned = 'onCommunityUserBanned',
+  OnCommunityUserChanged = 'onCommunityUserChanged',
+  OnCommunityUserRoleAdded = 'onCommunityUserRoleAdded',
+  OnCommunityUserRoleRemoved = 'onCommunityUserRoleRemoved',
+  OnCommunityUserUnbanned = 'onCommunityUserUnbanned',
+}

package/src/communityRepository/communityMembership/observers/searchMembers.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache } from '~/cache/api';
+import { SearchCommunityMembersLiveCollectionController } from './searchMembers/SearchCommunityMembersLiveCollectionController';
+
+/* begin_public_function
+  id: community.membership.query
+*/
+/**
+ * ```js
+ * import { searchMembers } from '@amityco/ts-sdk-react-native'
+ *
+ * let communityMembers = []
+ * const unsub = searchMembers({
+ *   communityId: Amity.Community['communityId'],
+ * }, response => merge(communityMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.CommunityUser}s
+ *
+ * @param params for querying community users
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the community users
+ *
+ * @category Community Live Collection
+ */
+export const searchMembers = (
+  params: Amity.SearchCommunityMemberLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'community'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getMembers(tmpid: ${timestamp}) > listen`);
+
+  const searchCommunityMemberLiveCollection = new SearchCommunityMembersLiveCollectionController(
+    params,
+    resp => {
+      callback(resp);
+    },
+  );
+  const disposers = searchCommunityMemberLiveCollection.startSubscription();
+
+  const cacheKey = searchCommunityMemberLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

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

@@ -0,0 +1,155 @@
+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,
+  onCommunityUserChanged,
+} from '~/communityRepository/communityMembership';
+
+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 },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Community>(['community', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => 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);
+    }
+
+    if (!this.query.displayName) {
+      const sortFn = (() => {
+        switch (this.query.sortBy) {
+          case 'firstCreated':
+            return sortByFirstCreated;
+          case 'lastCreated':
+            return sortByLastCreated;
+          case 'displayName':
+            return sortByDisplayName;
+          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),
+          keyword: params.displayName,
+          filter: params.membership,
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

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

@@ -0,0 +1,89 @@
+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.Community) => {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      if (this.query.displayName && action === EnumCommunityActions.OnCommunityCreated) {
+        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.Community) => 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',
+}