@amityco/ts-sdk-react-native 6.30.4-48268a5.0 → 6.30.4

package/dist/report/api/isReportedByMe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isReportedByMe.d.ts","sourceRoot":"","sources":["../../../src/report/api/isReportedByMe.ts"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;KAYK;AACL,eAAO,MAAM,cAAc,kBACV,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,eACzC,MAAM,KAClB,QAAQ,OAAO,CAqBjB,CAAC"}
+{"version":3,"file":"isReportedByMe.d.ts","sourceRoot":"","sources":["../../../src/report/api/isReportedByMe.ts"],"names":[],"mappings":"AAgEA;;;;;;;;;;;;KAYK;AACL,eAAO,MAAM,cAAc,kBACV,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,eACzC,MAAM,KAClB,QAAQ,OAAO,CAqBjB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.30.4-48268a5.0",
+  "version": "6.30.4",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

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

@@ -181,6 +181,8 @@ declare global {
     };
 
     type LocalCommunityEvents = {
+      'local.community.joined': Amity.CommunityMembershipPayload;
+      'local.community.left': Amity.CommunityMembershipPayload;
       'local.community.roleAdded': Amity.ProcessedCommunityPayload;
       'local.community.roleRemoved': Amity.ProcessedCommunityPayload;
       'local.community.userAdded': Amity.CommunityMembershipPayload;

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

@@ -273,6 +273,9 @@ declare global {
       files: Amity.File[];
     };
 
+    type RecommendedCommunityPayload = Amity.CommunityPayload;
+    type TrendingCommunityPayload = Amity.CommunityPayload;
+
     /**
      * Items that extend from `Amity.CommunityPayload`
      * - communities: `Amity.RawCommunity` -> `Amity.Community` (Added Marker Service related props)

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

@@ -133,6 +133,9 @@ declare global {
 
     type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
 
+    type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
+    type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{ limit?: number }>;
+
     type SearchCommunityLiveCollection = Amity.LiveCollectionParams<
       Omit<SearchQueryCommunities, 'page'>
     >;
@@ -142,6 +145,9 @@ declare global {
       Pick<QueryCommunities, 'page'>
     >;
 
+    type RecommendedCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
+    type TrendingCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
+
     type SearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<
       Amity.Community['communityId'],
       Pick<SearchQueryCommunities, 'page'>

package/src/client/api/index.ts

@@ -18,3 +18,6 @@ export * from './markerSync';
 export * from './enableUnreadCount';
 
 export * from './setUploadedFileAccessType';
+
+export * from './registerPushNotification';
+export * from './unregisterPushNotification';

package/src/communityRepository/api/joinCommunity.ts

@@ -31,7 +31,7 @@ export const joinCommunity = async (
     `/api/v3/communities/${communityId}/join`,
   );
 
-  fireEvent('community.joined', payload);
+  fireEvent('local.community.joined', payload);
 
   const data = prepareCommunityPayload(payload);
 

package/src/communityRepository/api/leaveCommunity.ts

@@ -31,7 +31,7 @@ export const leaveCommunity = async (
     `/api/v3/communities/${communityId}/leave`,
   );
 
-  fireEvent('community.left', payload);
+  fireEvent('local.community.left', payload);
 
   const data = prepareCommunityPayload(payload);
 

package/src/communityRepository/communityMembership/events/index.ts

@@ -10,3 +10,5 @@ export * from './onLocalCommunityUserRemoved';
 
 export * from './onCommunityJoined';
 export * from './onCommunityLeft';
+export * from './onLocalCommunityJoined';
+export * from './onLocalCommunityLeft';

package/src/communityRepository/communityMembership/events/onLocalCommunityJoined.ts

@@ -0,0 +1,5 @@
+import { createLocalCommunityMemberEventSubscriber } from './utils';
+
+export const onLocalCommunityJoined = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+) => createLocalCommunityMemberEventSubscriber('local.community.joined', callback);

package/src/communityRepository/communityMembership/events/onLocalCommunityLeft.ts

@@ -0,0 +1,5 @@
+import { createLocalCommunityMemberEventSubscriber } from './utils';
+
+export const onLocalCommunityLeft = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+) => createLocalCommunityMemberEventSubscriber('local.community.left', callback);

package/src/communityRepository/communityMembership/events/utils.ts

@@ -35,8 +35,6 @@ function getEventRelatedMember(
     return payload.communityUsers;
   }
 
-  // NOTE: backend returns the one who took the action and the one on whom
-  // the action was taken. We need the 2nd one
   if (event === 'community.userRemoved' || event === 'local.community.userRemoved') {
     return payload.communityUsers!.filter(x => x.communityMembership === 'none');
   }

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersLiveCollectionController.ts

@@ -13,6 +13,8 @@ import {
   onCommunityUserUnbanned,
   onLocalCommunityUserAdded,
   onLocalCommunityUserRemoved,
+  onLocalCommunityLeft,
+  onLocalCommunityJoined,
 } from '~/communityRepository/communityMembership/events';
 import {
   filterByPropIntersection,
@@ -84,7 +86,9 @@ export class CommunityMembersLiveCollectionController extends LiveCollectionCont
   startSubscription() {
     return this.queryStreamController.subscribeRTE([
       { fn: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
       { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
       { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
       { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
       { fn: onCommunityUserRoleAdded, action: EnumCommunityMemberActions.OnCommunityUserRoleAdded },

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

@@ -11,6 +11,8 @@ import {
   onCommunityUserChanged,
   onCommunityUserRoleRemoved,
   onCommunityUserUnbanned,
+  onLocalCommunityLeft,
+  onLocalCommunityJoined,
 } from '~/communityRepository/communityMembership/events';
 import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
 import { prepareCommunityPayload } from '~/communityRepository/utils';
@@ -78,7 +80,9 @@ export class SearchCommunityMembersLiveCollectionController extends LiveCollecti
   startSubscription() {
     return this.queryStreamController.subscribeRTE([
       { fn: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+      { fn: onLocalCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
       { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+      { fn: onLocalCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
       { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
       { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
       {

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

@@ -22,8 +22,11 @@ import { EnumCommunityMemberActions } from '~/communityRepository/communityMembe
 import {
   onCommunityJoined,
   onCommunityLeft,
+  onLocalCommunityJoined,
+  onLocalCommunityLeft,
   onCommunityUserChanged,
 } from '~/communityRepository/communityMembership';
+import { isNonNullable } from '~/utils';
 
 export class CommunityLiveCollectionController extends LiveCollectionController<
   'community',
@@ -87,6 +90,8 @@ export class CommunityLiveCollectionController extends LiveCollectionController<
       { 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 },
     ]);
   }
 
@@ -96,8 +101,8 @@ export class CommunityLiveCollectionController extends LiveCollectionController<
 
     const data = this.applyFilter(
       collection.data
-        .map(id => pullFromCache<Amity.Community>(['community', 'get', id])!)
-        .filter(Boolean)
+        .map(id => pullFromCache<Amity.Community>(['community', 'get', id]))
+        .filter(isNonNullable)
         .map(({ data }) => data) ?? [],
     );
 

package/src/communityRepository/observers/getCommunity.ts

@@ -7,6 +7,8 @@ import {
   onCommunityUserChanged,
   onCommunityJoined,
   onCommunityLeft,
+  onLocalCommunityJoined,
+  onLocalCommunityLeft,
 } from '../communityMembership/events';
 
 /* begin_public_function
@@ -40,6 +42,8 @@ export const getCommunity = (
     onCommunityDeleted,
     onCommunityJoined,
     onCommunityLeft,
+    onLocalCommunityJoined,
+    onLocalCommunityLeft,
     onCommunityUserBanned,
     onCommunityUserUnbanned,
     onCommunityUserChanged,

package/src/communityRepository/observers/getRecommendedCommunities/RecommendedCommunitiesLiveCollectionController.ts

@@ -0,0 +1,109 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { RecommendedCommunitiesPaginationController } from './RecommendedCommunitiesPaginationController';
+import { RecommendedCommunitiesQueryStreamController } from './RecommendedCommunitiesQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+import { EnumCommunityActions } from './enums';
+import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
+import { onCommunityDeleted, onCommunityUpdated } from '~/communityRepository/events';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onLocalCommunityJoined,
+  onLocalCommunityLeft,
+  onCommunityUserChanged,
+} from '~/communityRepository/communityMembership';
+import { isNonNullable } from '~/utils';
+
+export class RecommendedCommunityLiveCollectionController extends LiveCollectionController<
+  'community',
+  Amity.RecommendedCommunityLiveCollection,
+  Amity.Community,
+  RecommendedCommunitiesPaginationController
+> {
+  private queryStreamController: RecommendedCommunitiesQueryStreamController;
+
+  private query: Amity.RecommendedCommunityLiveCollection;
+
+  constructor(
+    query: Amity.RecommendedCommunityLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Community>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['community', 'collection', queryStreamId];
+    const paginationController = new RecommendedCommunitiesPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new RecommendedCommunitiesQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.RecommendedCommunityLiveCollectionCache>(
+      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: 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 },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.RecommendedCommunityLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data =
+      collection.data
+        .map(id => pullFromCache<Amity.Community>(['community', '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,
+    });
+  }
+}

package/src/communityRepository/observers/getRecommendedCommunities/RecommendedCommunitiesPaginationController.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 RecommendedCommunitiesPaginationController extends PaginationController<
+  'community',
+  Amity.RecommendedCommunityLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.RecommendedCommunityLiveCollection,
+    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/recommended`,
+      {
+        params: {
+          ...params,
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/communityRepository/observers/getRecommendedCommunities/RecommendedCommunitiesQueryStreamController.ts

@@ -0,0 +1,88 @@
+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 RecommendedCommunitiesQueryStreamController extends QueryStreamController<
+  Amity.RecommendedCommunityPayload,
+  Amity.RecommendedCommunityLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.RecommendedCommunityPayload,
+  ) => Amity.ProcessedCommunityPayload;
+
+  constructor(
+    query: Amity.RecommendedCommunityLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.RecommendedCommunityPayload,
+    ) => Amity.ProcessedCommunityPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.RecommendedCommunityPayload) {
+    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.RecommendedCommunityPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.communities.map(getResolver('community')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.RecommendedCommunityLiveCollectionCache>(
+        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.RecommendedCommunityLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      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/getRecommendedCommunities/enums.ts

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

package/src/communityRepository/observers/getRecommendedCommunities.ts

@@ -1,18 +1,9 @@
-/* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
 import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
-import { createQuery, queryOptions, runQuery } from '~/core/query';
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-  ENABLE_CACHE_MESSAGE,
-} from '~/utils/constants';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 
-import { onCommunityUserChanged } from '../communityMembership/events';
 import { getRecommendedCommunities as _getRecommendedCommunities } from '../api/getRecommendedCommunities';
-import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
-import { communityQueryFilter } from '../utils/communityQueryFilter';
+import { RecommendedCommunityLiveCollectionController } from './getRecommendedCommunities/RecommendedCommunitiesLiveCollectionController';
 
 /* begin_public_function
   id: community.query.recommended_communities
@@ -36,7 +27,7 @@ import { communityQueryFilter } from '../utils/communityQueryFilter';
  * @category Community Live Collection
  */
 export const getRecommendedCommunities = (
-  params: Amity.PageLimit,
+  params: Amity.RecommendedCommunityLiveCollection,
   callback: Amity.LiveCollectionCallback<Amity.Community>,
   config?: Amity.LiveCollectionConfig,
 ) => {
@@ -49,77 +40,14 @@ export const getRecommendedCommunities = (
   const timestamp = Date.now();
   log(`getRecommendedCommunities(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit, ...queryParams } = params;
+  const recommendedCommunitiesLiveCollection = new RecommendedCommunityLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = recommendedCommunitiesLiveCollection.startSubscription();
 
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+  const cacheKey = recommendedCommunitiesLiveCollection.getCacheKey();
 
-  const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['community', 'recommended', { params: { options: { limit } } }];
-
-  const responder = (data: Amity.CommunityLiveCollectionCache, isEventModel = false) => {
-    const communities: Amity.Community[] =
-      data.data
-        .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
-        .filter(Boolean)
-        .map(({ data }) => data) ?? [];
-
-    callback({
-      onNextPage: onFetch,
-      data: isEventModel ? communityQueryFilter(communities, params, userId!) : communities,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (_: Amity.CommunityActionType) => (community: Amity.Community) => {
-    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
-
-    /*
-     * Simply update collection and let responder decide what to do with data
-     */
-    collection.data = [...new Set([community.communityId, ...collection.data])];
-
-    pushToCache(cacheKey, collection);
-    responder(collection);
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
-
-    const communities = collection?.data ?? [];
-
-    if (!initial && communities.length > 0 && !collection?.params.page) return;
-
-    const query = createQuery(_getRecommendedCommunities, params);
-
-    runQuery(
-      query,
-      ({ data: result, error, loading }) => {
-        const data = {
-          loading,
-          error,
-          params,
-          data: communities,
-        };
-
-        if (result) {
-          data.data = [...new Set([...communities, ...result.map(getResolver('community'))])];
-        }
-
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
-
-  disposers.push(onCommunityUserChanged(realtimeRouter('onMemberCountChanged')));
-
-  onFetch(true);
   disposers.push(() => dropFromCache(cacheKey));
 
   return () => {

package/src/communityRepository/observers/getTrendingCommunities/TrendingCommunitiesLiveCollectionController.ts

@@ -0,0 +1,109 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { TrendingCommunitiesPaginationController } from './TrendingCommunitiesPaginationController';
+import { TrendingCommunitiesQueryStreamController } from './TrendingCommunitiesQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { onCommunityDeleted, onCommunityUpdated } from '~/communityRepository/events';
+import { prepareCommunityPayload } from '~/communityRepository/utils';
+import { EnumCommunityActions } from './enums';
+import { EnumCommunityMemberActions } from '~/communityRepository/communityMembership/observers/getMembers/enums';
+import {
+  onCommunityJoined,
+  onCommunityLeft,
+  onLocalCommunityJoined,
+  onLocalCommunityLeft,
+  onCommunityUserChanged,
+} from '~/communityRepository/communityMembership';
+import { isNonNullable } from '~/utils';
+
+export class TrendingCommunityLiveCollectionController extends LiveCollectionController<
+  'community',
+  Amity.TrendingCommunityLiveCollection,
+  Amity.Community,
+  TrendingCommunitiesPaginationController
+> {
+  private queryStreamController: TrendingCommunitiesQueryStreamController;
+
+  private query: Amity.TrendingCommunityLiveCollection;
+
+  constructor(
+    query: Amity.TrendingCommunityLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Community>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['trendingCommunity', 'collection', queryStreamId];
+    const paginationController = new TrendingCommunitiesPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new TrendingCommunitiesQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommunityPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.TrendingCommunityLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.TrendingCommunityPayload & 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: 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 },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.TrendingCommunityLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data =
+      collection.data
+        .map(id => pullFromCache<Amity.Community>(['community', '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,
+    });
+  }
+}