@amityco/ts-sdk 6.4.6-e12bdf9.0 → 6.5.0

package/src/client/observers/getTotalUnreadCount.ts

@@ -33,15 +33,9 @@ export const getTotalUnreadCount = (
       Amity.ErrorLevel.ERROR,
     );
 
-  const callbackDataSelector = (data: Amity.UserMarker) => data?.unreadCount ?? 0;
-
-  // based on the mobile specs, unreadCount will not trigger observer when userMarker
-  // is re-fetched, so apply this filter to ensure the behavior is the same.
-  const callbackFilter = (newModel: Amity.UserMarker, oldModel: Amity.UserMarker) =>
-    newModel?.unreadCount !== oldModel?.unreadCount;
+  const callbackDataSelector = (data: Amity.UserMarker | undefined) => data?.unreadCount ?? 0;
 
   return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
     callbackDataSelector,
-    callbackFilter,
   });
 };

package/src/client/observers/tests/getTotalUnreadCount.test.ts

@@ -59,7 +59,7 @@ describe('getTotalUnreadCount', () => {
 
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledTimes(2);
     // on initial, expect 0 unread count
     expect(callback).toHaveBeenLastCalledWith({
       origin: 'server',
@@ -72,7 +72,7 @@ describe('getTotalUnreadCount', () => {
 
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledTimes(3);
     expect(callback).toHaveBeenLastCalledWith(expected);
   });
 
@@ -89,12 +89,6 @@ describe('getTotalUnreadCount', () => {
     await pause();
 
     // initial callback
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    client.emitter.emit('local.userMarker.fetched', refreshUpdateTime(eventPayload));
-
-    await pause();
-
     expect(callback).toHaveBeenCalledTimes(2);
 
     // emit duplicated event
@@ -102,7 +96,6 @@ describe('getTotalUnreadCount', () => {
 
     await pause();
 
-    // should not re-trigger
-    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledTimes(3);
   });
 });

package/src/client/utils/markerSyncEngine.ts

@@ -4,7 +4,7 @@ import {
   onChannelJoined,
   onChannelLeft,
 } from '~/channelRepsitory';
-import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync'
+import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync';
 import { setIntervalTask } from '~/utils/timer';
 import { getUserMarker } from '~/marker/api';
 import { onFeedMarkerUpdated } from '~/marker/events';
@@ -15,6 +15,7 @@ import { isUnreadCountSupport } from '~/subChannelRepository/utils';
 import { markerSync } from '../api';
 
 const SYNC_TRIGGER_INTERVAL_TIME = 2000;
+const ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY = 2000;
 
 let clearSyncTrigger: Amity.Unsubscriber | undefined;
 let disposers: (() => void)[] = [];
@@ -138,7 +139,17 @@ const registerEventListeners = () => {
     onChannelJoined(() => events.push(Amity.MarkerSyncEvent.CHANNEL_JOINED)),
     onChannelLeft(() => events.push(Amity.MarkerSyncEvent.CHANNEL_LEFT)),
     onSubChannelCreated(() => events.push(Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED)),
-    onSubChannelDeleted(() => events.push(Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED)),
+    onSubChannelDeleted(() =>
+      /*
+       workaround: when receiving the event for sub-channel deletion,
+       before triggering marker update, the SDK will have to add a 2-second delay.
+       so that the unread count is calculated correctly.
+      */
+      setTimeout(
+        () => events.push(Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED),
+        ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY,
+      ),
+    ),
     onFeedMarkerUpdated(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
     onUserMarkerSync(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
   );

package/src/commentRepository/events/onCommentReactionAdded.ts

@@ -24,7 +24,7 @@ export const onCommentReactionAdded = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
     if (!client.cache) {
       callback(payload.comments[0]);
     } else {

package/src/commentRepository/events/onCommentReactionRemoved.ts

@@ -24,7 +24,7 @@ export const onCommentReactionRemoved = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
     if (!client.cache) {
       callback(payload.comments[0]);
     } else {

package/src/commentRepository/observers/getComment.ts

@@ -14,11 +14,11 @@ import {
 */
 /**
  * ```js
- * import { getComment } from '@amityco/ts-sdk';
+ * import { CommentRepository } from '@amityco/ts-sdk';
  *
  * let comment;
  *
- * const unsubscribe = getComment(commentId, response => {
+ * const unsub = CommentRepository.getComment(commentId, response => {
  *   comment = response.data;
  * });
  * ```

package/src/commentRepository/observers/tests/getComment.test.ts

@@ -75,12 +75,10 @@ describe('getComment', () => {
       data: { text: 'new-text' },
       updatedAt: getFutureDate(comment.updatedAt),
     };
-    const reactor: Amity.Reaction = {
+    const reactor: Amity.Reactor = {
       createdAt: getFutureDate(comment.updatedAt),
       reactionId: 'like',
       reactionName: 'like',
-      referenceId: comment.commentId,
-      referenceType: 'comment',
       userId: user12.userId,
     };
     const callback = jest.fn();

package/src/communityRepository/api/getCommunity.ts

@@ -7,8 +7,8 @@ import { prepareCommunityPayload } from '../utils';
 
 /**
  * ```js
- * import { getCommunity } from '@amityco/ts-sdk'
- * const community = await getCommunity('foobar')
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const community = await CommunityRepository.getCommunity('foobar')
  * ```
  *
  * Fetches a {@link Amity.Community} object
@@ -45,8 +45,8 @@ export const getCommunity = async (
 
 /**
  * ```js
- * import { getCommunity } from '@amityco/ts-sdk'
- * const community = getCommunity.locally('foobar')
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const community = CommunityRepository.getCommunity.locally('foobar')
  * ```
  *
  * Fetches a {@link Amity.Community} object from cache

package/src/communityRepository/api/getRecommendedCommunities.ts

@@ -5,14 +5,15 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareCommunityPayload } from '../utils';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
 
 /* begin_public_function
   id: community.query.recommended_communities
 */
 /**
  * ```js
- * import { getRecommendedCommunities } from '@amityco/ts-sdk'
- * const communities = await getRecommendedCommunities()
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const communities = await CommunityRepository.getRecommendedCommunities()
  * ```
  *
  * Gets a list of recommended {@link Amity.Community} objects
@@ -22,14 +23,15 @@ import { prepareCommunityPayload } from '../utils';
  *
  * @category Community API
  * @async
+ * @private
  */
 export const getRecommendedCommunities = async (
-  query?: Partial<Amity.PageLimit>,
+  query?: Amity.PageLimit,
 ): Promise<Amity.Cached<Amity.Community[]>> => {
   const client = getActiveClient();
-  client.log('channel/getRecommendedCommunities', query);
+  client.log('community/getRecommendedCommunities', query);
 
-  const { limit = 5 } = query ?? {};
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = query ?? {};
 
   // API-FIX: backend doesnt answer Amity.Response
   // const { data: payload } = await client.http.get<Amity.Response<CommunityPayload>>(
@@ -45,50 +47,7 @@ export const getRecommendedCommunities = async (
 
   if (client.cache) {
     ingestInCache(data, { cachedAt });
-
-    const cacheKey = ['community', 'recommended', { params: { options: { limit } } }];
-    pushToCache(cacheKey, { communities: communities.map(getResolver('community')) });
   }
 
   return { data: communities, cachedAt };
 };
-/* end_public_function */
-
-/**
- * ```js
- * import { getRecommendedCommunities } from '@amityco/ts-sdk'
- * const communities = getRecommendedCommunities.locally()
- * ```
- *
- * Gets a list of recommended {@link Amity.Community} objects from cache
- *
- * @param query The query parameters
- * @returns communities
- *
- * @category Community API
- */
-getRecommendedCommunities.locally = (
-  query: Parameters<typeof getRecommendedCommunities>[0],
-): Amity.Cached<Amity.Community[]> | undefined => {
-  const client = getActiveClient();
-  client.log('community/getRecommendedCommunities.locally', query);
-
-  if (!client.cache) return;
-
-  const { limit = 5 } = query ?? {};
-
-  const queryKey = ['community', 'recommended', { params: { options: { limit } } }];
-  const { data, cachedAt } =
-    pullFromCache<{ communities: Pick<Amity.Community, 'communityId'>[] }>(queryKey) ?? {};
-
-  if (!data?.communities.length) return;
-
-  const communities: Amity.Community[] = data.communities
-    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
-    .filter(Boolean)
-    .map(({ data }) => data);
-
-  return communities.length === data?.communities?.length
-    ? { data: communities, cachedAt }
-    : undefined;
-};

package/src/communityRepository/api/getTopTrendingCommunities.ts

@@ -10,9 +10,12 @@ import { prepareCommunityPayload } from '../utils';
   id: community.query.trending_communities
 */
 /**
+ * @deprecated This API renamed to `getTrendingCommunities()`.
+ * Please use getTrendingCommunities() instead.
+ *
  * ```js
- * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
- * const trendingCommunities = await getTopTrendingCommunities()
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const trendingCommunities = await CommunityRepository.getTrendingCommunities()
  * ```
  *
  * Gets a list of top trending {@link Amity.Community} objects

package/src/communityRepository/api/getTrendingCommunities.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api';
+
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareCommunityPayload } from '../utils';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const trendingCommunities = await CommunityRepository.getTrendingCommunities()
+ * ```
+ *
+ * Gets a list of top trending {@link Amity.Community} objects
+ *
+ * @param query The query parameters
+ * @returns A list of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ * @private
+ */
+export const getTrendingCommunities = async (
+  query?: Amity.PageLimit,
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient();
+  client.log('community/getTrendingCommunities', query);
+
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = 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 } } },
+  );
+
+  const data = prepareCommunityPayload(payload);
+  const { communities } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+  }
+
+  return { data: communities, cachedAt };
+};

package/src/communityRepository/api/index.ts

@@ -7,5 +7,5 @@ export * from './deleteCommunity';
 export * from './joinCommunity';
 export * from './leaveCommunity';
 
+// deprecated
 export * from './getTopTrendingCommunities';
-export * from './getRecommendedCommunities';

package/src/communityRepository/api/test/getTrendingCommunities.test.ts

@@ -0,0 +1,102 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getTrendingCommunities } from '../getTrendingCommunities';
+
+const topTrendCommunities = [community11, community21];
+const topTrendIds = topTrendCommunities.map(({ communityId }) => communityId);
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const resolvedGetValue = {
+  data: {
+    communities: topTrendCommunities,
+    communityUsers: [community11, community21],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('getTrendingCommunities', () => {
+  test('should return fetched top trend communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getTrendingCommunities(pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({ data: topTrendCommunities }),
+    );
+  });
+
+  test('should update cache after fetching top trend communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getTrendingCommunities(pagingCriteria);
+
+    const recieved = pullFromCache([
+      'community',
+      'top-trending',
+      { params: { options: pagingCriteria } },
+    ])?.data;
+
+    expect(recieved).toEqual({ communities: topTrendIds });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getTrendingCommunities(pagingCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('getTopTrendingCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached top trend communities', () => {
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTrendingCommunities.locally(pagingCriteria)?.data).toEqual(topTrendCommunities);
+  });
+
+  test('it should return undefined if top trend communities not in cache', () => {
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTrendingCommunities.locally({ limit: -1 })).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTrendingCommunities.locally(pagingCriteria)).toBeUndefined();
+  });
+});

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

@@ -27,6 +27,35 @@ import {
 } from '../events';
 import { queryCommunityMembers } from '../api/queryCommunityMembers';
 
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.Membership<'community'>>(
+  data: T[],
+  params: Amity.CommunityMemberLiveCollection,
+): T[] => {
+  let communityMembers = filterByPropIntersection(data, 'roles', params.roles);
+
+  if (params.membership) {
+    communityMembers = communityMembers.filter(({ communityMembership }) =>
+      // @ts-ignore
+      params.membership.includes(communityMembership),
+    );
+  }
+
+  if (params.search) {
+    communityMembers = filterBySearchTerm(communityMembers, params.search);
+  }
+
+  const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+  communityMembers = communityMembers.sort(
+    sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+  );
+
+  return communityMembers;
+};
+
 /* begin_public_function
   id: community.membership.query
 */
@@ -56,6 +85,7 @@ export const getMembers = (
   const { log, cache } = getActiveClient();
 
   if (!cache) {
+    // eslint-disable-next-line no-console
     console.log(ENABLE_CACHE_MESSAGE);
   }
 
@@ -70,28 +100,6 @@ export const getMembers = (
   const disposers: Amity.Unsubscriber[] = [];
   const cacheKey = ['communityUsers', 'collection', { communityId: params.communityId }];
 
-  const applyFilter = <T extends Amity.Membership<'community'>>(data: T[]): T[] => {
-    let communityMembers = filterByPropIntersection(data, 'roles', params.roles);
-
-    if (params.membership) {
-      communityMembers = communityMembers.filter(({ communityMembership }) =>
-        // @ts-ignore
-        params.membership.includes(communityMembership),
-      );
-    }
-
-    if (params.search) {
-      communityMembers = filterBySearchTerm(communityMembers, params.search);
-    }
-
-    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
-    communityMembers = communityMembers.sort(
-      sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
-    );
-
-    return communityMembers;
-  };
-
   const responder = (data: Amity.CommunityMemberLiveCollectionCache, isEventModel = false) => {
     const communityMembers: Amity.Membership<'community'>[] =
       data.data
@@ -101,7 +109,7 @@ export const getMembers = (
 
     callback({
       onNextPage: onFetch,
-      data: isEventModel ? applyFilter(communityMembers) : communityMembers,
+      data: isEventModel ? applyFilter(communityMembers, params) : communityMembers,
       hasNextPage: !!data.params?.page,
       loading: data.loading,
       error: data.error,

package/src/communityRepository/communityMembership/observers/tests/getMembers.test.ts

@@ -1,5 +1,5 @@
+import { getPastDate } from '~/core/model';
 import { disableCache, enableCache } from '~/cache/api';
-
 import {
   client,
   connectClient,
@@ -19,7 +19,10 @@ import {
   convertedCommunityUser3,
 } from '~/utils/tests';
 
-import { getMembers } from '../getMembers';
+// makes it easier to spy on applyFilter
+import * as getMembersModule from '../getMembers';
+
+const { getMembers, applyFilter } = getMembersModule;
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
@@ -166,4 +169,79 @@ describe('getMembers', () => {
       ),
     );
   });
+
+  test('it should apply fileters on RTE only', async () => {
+    const callback = jest.fn();
+    const applyFilterSpy = jest.spyOn(getMembersModule, 'applyFilter');
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
+
+    getMembers({ communityId, sortBy: 'firstCreated' }, callback);
+    await pause();
+
+    expect(applyFilterSpy).not.toHaveBeenCalled();
+
+    client.emitter.emit('community.joined', {
+      communities: [community11],
+      communityUsers: [communityUser13],
+      users: [user13],
+      files: [],
+      categories: [],
+      feeds: [],
+    });
+    await pause();
+
+    expect(applyFilterSpy).toHaveBeenCalled();
+  });
+});
+
+describe('getMembers > applyFilter', () => {
+  const { communityId } = community11;
+
+  const m1 = {
+    communityId,
+    userId: 'test',
+    communityMembership: 'member',
+    roles: ['test-role'],
+    createdAt: new Date().toISOString(),
+  } as Amity.Membership<'community'>;
+
+  const m2 = {
+    communityId,
+    userId: 'searchable',
+    communityMembership: 'banned',
+    createdAt: getPastDate(),
+  } as Amity.Membership<'community'>;
+
+  const filters: [
+    string,
+    Amity.CommunityMemberLiveCollection,
+    Amity.Membership<'community'>[],
+    Amity.Membership<'community'>[],
+  ][] = [
+    ['it should filter by roles', { communityId, roles: ['test-role'] }, [m1, m2], [m1]],
+    [
+      'it should filter by membership:member',
+      { communityId, membership: ['member'] },
+      [m1, m2],
+      [m1],
+    ],
+    [
+      'it should filter by membership:banned',
+      { communityId, membership: ['banned'] },
+      [m1, m2],
+      [m2],
+    ],
+    ['it should sort by last created', { communityId }, [m1, m2], [m1, m2]],
+    [
+      'it should sort by first created',
+      { communityId, sortBy: 'firstCreated' },
+      [m1, m2],
+      [m2, m1],
+    ],
+    ['it should filter by search term', { communityId, search: 'sea' }, [m1, m2], [m2]],
+  ];
+
+  test.each(filters)('%s', (test, param, input, expected) => {
+    expect(applyFilter(input, param)).toStrictEqual(expected);
+  });
 });

package/src/communityRepository/observers/getCommunities.ts

@@ -31,10 +31,10 @@ import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
 */
 /**
  * ```js
- * import { getCommunities } from '@amityco/ts-sdk'
+ * import { CommunityRepository } from '@amityco/ts-sdk'
  *
  * let communities = []
- * const unsub = getCommunities({
+ * const unsub = CommunityRepository.getCommunities({
  *   displayName: Amity.Community['displayName'],
  * }, response => merge(communities, response.data))
  * ```

package/src/communityRepository/observers/getCommunity.ts

@@ -14,11 +14,11 @@ import {
 */
 /**
  * ```js
- * import { getCommunity } from '@amityco/ts-sdk';
+ * import { CommunityRepository } from '@amityco/ts-sdk';
  *
  * let community;
  *
- * const unsubscribe = getCommunity(communityId, response => {
+ * const unsub = CommunityRepository.getCommunity(communityId, response => {
  *   community = response.data;
  * });
  * ```