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

package/src/communityRepository/observers/getRecommendedCommunities.ts

@@ -0,0 +1,130 @@
+/* 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 { getRecommendedCommunities as _getRecommendedCommunities } from '../api/getRecommendedCommunities';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { communityQueryFilter } from '../utils/communityQueryFilter';
+
+/* begin_public_function
+  id: community.query.recommended_communities
+*/
+/**
+ * ```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.PageLimit,
+  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(_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 () => {
+    log(`getRecommendedCommunities(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/communityRepository/observers/getTrendingCommunities.ts

@@ -0,0 +1,130 @@
+/* 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 { getTrendingCommunities as _getTrendingCommunities } from '../api/getTrendingCommunities';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { communityQueryFilter } from '../utils/communityQueryFilter';
+
+/* begin_public_function
+  id: community.query.trending_communities
+*/
+/**
+ * ```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.PageLimit,
+  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 } = 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(_getTrendingCommunities, 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 () => {
+    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();

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

@@ -201,7 +201,7 @@ describe('getPosts', () => {
   const reactionEvents: [
     string,
     keyof Amity.Events,
-    Amity.PostPayload & { reactor: Amity.Reaction },
+    Amity.PostPayload & { reactor: Amity.Reactor },
   ][] = [
     [
       'it should update post in collection onReactionAdded',
@@ -210,8 +210,6 @@ describe('getPosts', () => {
         ...emptyPostPayload,
         posts: [{ ...post11, reactionsCount: 1 }],
         reactor: {
-          referenceId: post11.postId,
-          referenceType: 'post',
           reactionId: 'test-reaction-id',
           reactionName: 'like',
           userId: 'test',
@@ -226,8 +224,6 @@ describe('getPosts', () => {
         ...emptyPostPayload,
         posts: [{ ...post11, reactionsCount: 0 }],
         reactor: {
-          referenceId: post11.postId,
-          referenceType: 'post',
           reactionId: 'test-reaction-id',
           reactionName: 'like',
           userId: 'test',

package/src/reactionRepository/api/addReaction.ts

@@ -27,7 +27,7 @@ import { dispatchReactable } from '../utils';
 export const addReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName'],
+  reactionName: Amity.Reactor['reactionName'],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('reaction/createReaction', {
@@ -76,7 +76,7 @@ export const addReaction = async (
 addReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName'],
+  reactionName: Amity.Reactor['reactionName'],
 ): boolean | undefined => {
   const client = getActiveClient();
   client.log('reaction/createReaction.optimistically', {

package/src/reactionRepository/api/queryReactions.ts

@@ -12,7 +12,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * })
  * ```
  *
- * Queries a paginable list of {@link Amity.ReactionQuery} objects
+ * Queries a paginable list of {@link Amity.Reaction} objects
  *
  * @param query The query parameters
  * @returns A page of {@link Amity.Reaction} objects
@@ -22,7 +22,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * */
 export const queryReactions = async (
   query: Amity.QueryReactions,
-): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page<string>>> => {
+): Promise<Amity.Paged<Amity.Reaction, Amity.Page<string>>> => {
   const client = getActiveClient();
   client.log('reaction/queryReactions', query);
 

package/src/reactionRepository/api/queryReactor.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { queryReactions } from './queryReactions';
+
+/**
+ * ```js
+ * import { queryReactor } from '@amityco/ts-sdk'
+ * const { data: reactions, prevPage, nextPage } = await queryReactor({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Reactor} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Reactor} objects
+ *
+ * @reaction Reaction API
+ * @async
+ * */
+export const queryReactor = async (
+  query: Amity.QueryReactions,
+): Promise<Amity.Paged<Amity.Reactor, Amity.Page<string>>> => {
+  const client = getActiveClient();
+  client.log('reaction/queryReactor', query);
+
+  const { data, ...response } = await queryReactions(query);
+
+  return { ...response, data: data[0].reactors };
+};

package/src/reactionRepository/api/removeReaction.ts

@@ -28,7 +28,7 @@ import { dispatchReactable } from '../utils';
 export const removeReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName'],
+  reactionName: Amity.Reactor['reactionName'],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('reaction/removeReaction', {
@@ -79,7 +79,7 @@ export const removeReaction = async (
 removeReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName'],
+  reactionName: Amity.Reactor['reactionName'],
 ): boolean | undefined => {
   const client = getActiveClient();
   client.log('reaction/removeReaction.optimistically', {