@amityco/ts-sdk 6.4.6-bdc04db.0 → 6.4.6-be7e4df.0

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/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;
  * });
  * ```

package/src/communityRepository/observers/getRecommendedCommunities.ts

@@ -0,0 +1,133 @@
+/* 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 { onCommunityUserChanged } from '../communityMembership/events';
+import { queryCommunities } from '../api/queryCommunities';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { communityQueryFilter } from '../utils/communityQueryFilter';
+
+/* begin_public_function
+  id: community.query
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ *
+ * let communities = []
+ * const unsub = CommunityRepository.getCommunities({
+ *   displayName: Amity.Community['displayName'],
+ * }, response => merge(communities, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Community}s
+ *
+ * @param params for querying communities
+ * @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 communities
+ *
+ * @category Community Live Collection
+ */
+export const getRecommendedCommunities = (
+  params: Amity.CommunityLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Community>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getRecommendedCommunities(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  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(queryCommunities, {
+      ...queryParams,
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          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 () => {
+    log(`getRecommendedCommunities(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/communityRepository/observers/getTrendingCommunities.ts

@@ -0,0 +1,133 @@
+/* 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 { onCommunityUserChanged } from '../communityMembership/events';
+import { queryCommunities } from '../api/queryCommunities';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { communityQueryFilter } from '../utils/communityQueryFilter';
+
+/* begin_public_function
+  id: community.query
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ *
+ * let communities = []
+ * const unsub = CommunityRepository.getCommunities({
+ *   displayName: Amity.Community['displayName'],
+ * }, response => merge(communities, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Community}s
+ *
+ * @param params for querying communities
+ * @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 communities
+ *
+ * @category Community Live Collection
+ */
+export const getTrendingCommunities = (
+  params: Amity.CommunityLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Community>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getTrendingCommunities(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['community', 'top-trending', { 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(queryCommunities, {
+      ...queryParams,
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          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 () => {
+    log(`getTrendingCommunities(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/communityRepository/observers/index.ts

@@ -2,3 +2,5 @@ export * from './observeCommunity';
 
 export * from './getCommunities';
 export * from './getCommunity';
+export * from './getTrendingCommunities';
+export * from './getRecommendedCommunities';

package/src/communityRepository/utils/communityQueryFilter.ts

@@ -0,0 +1,55 @@
+import {
+  filterByCommunityMembership,
+  filterByPropEquality,
+  sortByDisplayName,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+export const communityQueryFilter = (
+  data: Amity.Community[],
+  params: Amity.CommunityLiveCollection,
+  userId: string,
+): Amity.Community[] => {
+  let communities = data;
+  communities = filterByPropEquality(communities, 'displayName', params.displayName);
+
+  if (!params.includeDeleted) {
+    communities = filterByPropEquality(communities, 'isDeleted', false);
+  }
+
+  if (params.categoryId) {
+    communities = communities.filter(c => c.categoryIds?.includes(params.categoryId!));
+  }
+
+  if (params.tags) {
+    communities = communities.filter(c => c.tags?.some(t => params.tags?.includes(t)));
+  }
+
+  if (params.membership && userId) {
+    communities = filterByCommunityMembership(communities, params.membership, userId);
+  }
+
+  const sortBy = params.sortBy || 'lastCreated';
+
+  if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+    communities = communities.sort(
+      sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+    );
+  }
+
+  /*
+   * The server returns communities with empty | null displayName's first before
+   * returning sorted list of communities with displayNames
+   *
+   * This section needs to be updated as displayNames can be null as well
+   */
+  if (sortBy === 'displayName') {
+    communities = communities
+      // this needs to be aligned with the backend data type
+      .map(c => (c.displayName ? c : { ...c, displayName: '' }))
+      // @ts-ignore
+      .sort(sortByDisplayName);
+  }
+  return communities;
+};

package/src/core/model/idResolvers.ts

@@ -33,7 +33,8 @@ const idResolvers: Resolvers = {
   post: ({ postId }) => postId,
   comment: ({ commentId }) => commentId,
   poll: ({ pollId }) => pollId,
-  reaction: ({ reactionId }) => reactionId,
+  reaction: ({ referenceType, referenceId }) => `${referenceType}#${referenceId}`,
+  reactor: ({ reactionId }) => reactionId,
 
   stream: ({ streamId }) => streamId,
 

package/src/core/model/identifyModel.ts

@@ -21,10 +21,10 @@ type Criterias<T extends Amity.Domain = Amity.Domain> = {
  */
 const CRITERIAS: Criterias = {
   file: ['fileId', 'attributes'],
-  user: ['userId', 'avatarFileId'],
+  user: ['userId', 'avatarFileId', 'roles', 'permissions'],
   role: ['roleId'],
-  channel: ['channelId', 'rateLimit'],
-  subChannel: ['subChannelId'],
+  channel: ['channelId', 'defaultSubChannelId'],
+  subChannel: ['subChannelId', 'latestMessageId'],
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
   community: ['communityId', 'postSetting'],
@@ -33,7 +33,8 @@ const CRITERIAS: Criterias = {
   post: ['postId', 'feedId'],
   comment: ['commentId', 'referenceId'],
   poll: ['pollId'],
-  reaction: ['reactionId'],
+  reaction: ['referenceId', 'referenceType', 'reactors'],
+  reactor: ['reactionId'],
   stream: ['streamId'],
   follow: ['from', 'to'],
   feed: ['feedId', 'feedType'],

package/src/pollRepository/api/index.ts

@@ -1,5 +1,3 @@
-export * from './getPoll';
-
 export * from './createPoll';
 export * from './closePoll';
 export * from './deletePoll';

package/src/pollRepository/observers/getPoll.ts

@@ -0,0 +1,33 @@
+import { liveObject } from '~/utils/liveObject';
+import { getPoll as _getPoll } from '../api/getPoll';
+import { onPollDeleted, onPollUpdated } from '../events';
+
+/* begin_public_function
+  id: poll.get
+*/
+/**
+ * ```js
+ * import { PollRepository } from '@amityco/ts-sdk';
+ *
+ * let poll;
+ *
+ * const unsub = PollRepository.getPoll(commentId, response => {
+ *   poll = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Poll}
+ *
+ * @param pollId the ID of the poll to observe
+ * @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 poll
+ *
+ * @category Poll Live Object
+ */
+export const getPoll = (
+  pollId: Amity.Poll['pollId'],
+  callback: Amity.LiveObjectCallback<Amity.Poll>,
+): Amity.Unsubscriber => {
+  return liveObject(pollId, callback, 'pollId', _getPoll, [onPollUpdated, onPollDeleted]);
+};
+/* end_public_function */

package/src/pollRepository/observers/index.ts

@@ -1 +1,2 @@
 export * from './observePoll';
+export * from './getPoll';

package/src/pollRepository/observers/observePoll.ts

@@ -2,7 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { createQuery, runQuery, queryOptions } from '~/core/query';
 
-import { getPoll } from '../api';
+import { getPoll as _getPoll } from '../api/getPoll';
 
 import { onPollUpdated, onPollDeleted } from '../events';
 
@@ -55,7 +55,7 @@ export const observePoll = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
   );
 
   runQuery(
-    createQuery(getPoll, pollId),
+    createQuery(_getPoll, pollId),
     result => (result.data || result.error) && router(result, 'onFetch'),
     queryOptions(policy),
   );

package/src/postRepository/events/tests/onPostReactionAdded.test.ts

@@ -1,13 +1,14 @@
-import { onPostReactionAdded } from '../onPostReactionAdded';
 import {
   client,
   connectClient,
   disconnectClient,
   postPayload,
   post11,
-  reaction11,
+  reactor11,
 } from '~/utils/tests';
 
+import { onPostReactionAdded } from '../onPostReactionAdded';
+
 describe('onPostReactionAdded', () => {
   beforeAll(async () => {
     await connectClient();
@@ -20,12 +21,12 @@ describe('onPostReactionAdded', () => {
   test('it should got event after add reaction to post', () => {
     const callback = jest.fn();
     const unsub = onPostReactionAdded(callback);
-    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reactor11 });
 
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith({ ...post11, myReactions: [reaction11.reactionName] });
+    expect(callback).toHaveBeenCalledWith({ ...post11, myReactions: [reactor11.reactionName] });
   });
 
   test('it should got nothing if we did unsubscribe before got event', () => {
@@ -34,7 +35,7 @@ describe('onPostReactionAdded', () => {
 
     unsub();
 
-    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reactor11 });
     expect(callback).not.toHaveBeenCalled();
   });
 });

package/src/postRepository/events/tests/onPostReactionRemoved.test.ts

@@ -1,13 +1,14 @@
-import { onPostReactionRemoved } from '../onPostReactionRemoved';
 import {
   client,
   connectClient,
   disconnectClient,
   postPayload,
   post11,
-  reaction11,
+  reactor11,
 } from '~/utils/tests';
 
+import { onPostReactionRemoved } from '../onPostReactionRemoved';
+
 describe('onPostReactionRemoved', () => {
   beforeAll(async () => {
     await connectClient();
@@ -20,7 +21,7 @@ describe('onPostReactionRemoved', () => {
   test('it should got event after reaction got removed from post', () => {
     const callback = jest.fn();
     const unsub = onPostReactionRemoved(callback);
-    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reaction11 });
+    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reactor11 });
 
     unsub();
 
@@ -34,7 +35,7 @@ describe('onPostReactionRemoved', () => {
 
     unsub();
 
-    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reaction11 });
+    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reactor11 });
     expect(callback).not.toHaveBeenCalled();
   });
 });

package/src/postRepository/observers/getPost.ts

@@ -16,11 +16,11 @@ import {
 */
 /**
  * ```js
- * import { getPost } from '@amityco/ts-sdk';
+ * import { PostRepository } from '@amityco/ts-sdk';
  *
  * let post;
  *
- * const unsubscribe = getPost(postId, response => {
+ * const unsub = PostRepository.getPost(postId, response => {
  *   post = response.data;
  * });
  * ```

package/src/postRepository/observers/getPosts.ts

@@ -35,7 +35,7 @@ import {
 import { queryPosts } from '../api/queryPosts';
 
 /* begin_public_function
-  id: post.query, feed.query.community_feed, feed.query.user_feed
+  id: post.query
 */
 /**
  * ```js

package/src/postRepository/observers/tests/getPost.test.ts

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