@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.30

package/src/comment/observers/liveComments.ts

@@ -0,0 +1,172 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+import { queryComments } from '../api';
+
+/**
+ * ```js
+ * import { liveComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = liveComments({
+ *   referenceType: Amity.Comment['referenceType'];
+ *   referenceId: Amity.Comment['referenceId'];
+ * }, response => merge(comments, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @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 messages
+ *
+ * @category Comments Live Collection
+ */
+export const liveComments = (
+  params: Amity.CommentLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveComments(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 = [
+    'comment',
+    'collection',
+    { referenceId: params.referenceType, referenceType: params.referenceId },
+  ];
+
+  const responder = (data: Amity.CommentLiveCollectionCache) => {
+    let comments: Amity.Comment[] =
+      data.data
+        .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    comments = filterByPropEquality(comments, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    comments = comments.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: comments,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (comment: Amity.Comment, action: Amity.CommentActionType) => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    if (
+      params.referenceId !== comment.referenceId ||
+      params.referenceType !== comment.referenceType ||
+      !collection
+    )
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([comment.commentId, ...collection.data])];
+    } else if (action === 'onDelete') {
+      collection.data = collection.data.filter(p => p !== comment.commentId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    const comments = collection?.data ?? [];
+
+    if (comments.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryComments, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage, nextPage }) => {
+        // depend on sortBy value we have two different pagination type
+        const page = queryParams.sortBy ? nextPage : prevPage;
+
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: comments,
+        };
+
+        if (result) {
+          data.data = [...new Set([...comments, ...result.map(getResolver('comment'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommentCreated(comment => realtimeRouter(comment, 'onCreate')),
+    onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')),
+    onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')),
+    onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')),
+    onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/comment/observers/observeComment.ts

@@ -1,14 +1,17 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { createQuery, runQuery, queryOptions } from '~/core/query'
+import { createQuery, runQuery, queryOptions } from '~/core/query';
 
-import { getComment } from '../api'
+import { getComment } from '../api';
 
 import {
   onCommentUpdated,
   onCommentDeleted,
-} from '../events'
-
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
 
 /**
  * ```js
@@ -26,48 +29,68 @@ import {
  *
  * @category Comment Observer
  */
-export const observeComment = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+export const observeComment = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onFlagged',
+    'onUnflagged',
+    'onReactionAdded',
+    'onReactionRemoved',
+  ],
+>(
   commentId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Comment>, Events>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Comment | undefined>, Events>,
   policy: Amity.QueryPolicy = 'cache_then_server',
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeComment(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeComment(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (
-    result: Amity.QueryResult<Amity.Comment>,
-    action: Events[number]
-  ) => {
-    // filter function
-    if (result.data?.commentId !== commentId) return
+  const router = (result: Amity.Snapshot<Amity.Comment | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    if (callback instanceof Function)
-      return callback(result)
+    callback[action]?.(result);
+  };
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Comment>, action: Events[number]) => {
+    if (result.data?.commentId !== commentId) return;
 
-    callback[action]?.(result)
-  }
+    router(result, action);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onCommentUpdated(data => router({ data }, 'onUpdate')),
-    onCommentDeleted(data => router({ data }, 'onDelete')),
-  )
+    onCommentUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onCommentDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onCommentFlagged(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged'),
+    ),
+    onCommentUnflagged(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
+    ),
+    onCommentReactionAdded(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
+    ),
+    onCommentReactionRemoved(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
+    ),
+  );
 
   runQuery(
     createQuery(getComment, commentId),
-    result => result.data && router(result, 'onFetch'),
-    queryOptions(policy)
-  )
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
 
   return () => {
-    log(`observeComment(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeComment(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/comment/observers/observeComments.ts

@@ -1,10 +1,14 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
 import {
   onCommentCreated,
   onCommentUpdated,
   onCommentDeleted,
-} from '../events'
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
 
 /**
  * ```js
@@ -26,36 +30,45 @@ export const observeComments = (
   postId: Amity.Post['postId'],
   callback: Amity.ObjectListener<
     Amity.Comment,
-    ['onCreate', 'onUpdate', 'onDelete']
-  >
+    [
+      'onCreate',
+      'onUpdate',
+      'onDelete',
+      'onFlagged',
+      'onUnflagged',
+      'onReactionAdded',
+      'onReactionRemoved',
+    ]
+  >,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeComments(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeComments(tmpid: ${timestamp}) > listen`);
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    comment: Amity.Comment,
-    action: 'onCreate' | 'onUpdate' | 'onDelete'
-  ) => {
-    if (comment.referenceId !== postId) return
+  const router = (comment: Amity.Comment, action: Exclude<Amity.CommentActionType, 'onFetch'>) => {
+    if (comment.referenceId !== postId) return;
 
-    if (callback instanceof Function) return callback(comment)
+    if (callback instanceof Function) return callback(comment);
 
-    callback.onEvent?.(action, comment)
-    callback[action]?.(comment)
-  }
+    callback.onEvent?.(action, comment);
+    callback[action]?.(comment);
+  };
 
   disposers.push(
     onCommentCreated(comment => router(comment, 'onCreate')),
     onCommentUpdated(comment => router(comment, 'onUpdate')),
-    onCommentDeleted(comment => router(comment, 'onDelete'))
-  )
+    onCommentDeleted(comment => router(comment, 'onDelete')),
+    onCommentFlagged(comment => router(comment, 'onFlagged')),
+    onCommentUnflagged(comment => router(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => router(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => router(comment, 'onReactionRemoved')),
+  );
 
   return () => {
-    log(`observeComments(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/community/api/addCommunityMembers.ts

@@ -1,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -21,26 +20,23 @@ import { fireEvent } from '~/core/events'
  */
 export const addCommunityMembers = async (
   communityId: Amity.Community['communityId'],
-  userIds: Amity.User['userId'][]
-) => {
-  const client = getActiveClient()
-  client.log('community/addCommunityMembers', communityId, userIds)
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/addCommunityMembers', communityId, userIds);
 
   const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/users`,
-    { communityId, userIds }
-  )
+    { communityId, userIds },
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.community.didAddUsers', {
-    communities: data.communities!,
-  })
+  if (client.cache) ingestInCache(data);
 
-  const { communityUsers } = data
+  fireEvent('community.userAdded', data);
+
+  const { communityUsers } = data;
   return !!communityUsers.find(
     communityUser =>
-      communityUser.communityId === communityId &&
-      communityUser.communityMembership === 'member'
-  )
-}
+      communityUser.communityId === communityId && communityUser.communityMembership === 'member',
+  );
+};

package/src/community/api/addCommunityMembersRoles.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { addCommunityMembersRoles } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembersRoles(communityId, ['foo'], ['bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param roleIds Array of IDs of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addCommunityMembersRoles = async (
+  communityId: Amity.Community['communityId'],
+  roleIds: Amity.Role['roleId'][],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/addCommunityMembersRoles', communityId, roleIds, userIds);
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v4/communities/${communityId}/users/roles`,
+    { communityId, roles: roleIds, userIds },
+  );
+
+  if (client.cache) ingestInCache(data);
+
+  const { communityUsers } = data;
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId &&
+      roleIds.some(role => communityUser.roles.includes(role)),
+  );
+};

package/src/community/api/createCommunity.ts

@@ -1,8 +1,9 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { packCommunityPayload, unpackCommunityPayload } from '../utils';
 
 /**
  * ```js
@@ -21,23 +22,38 @@ import { fireEvent } from '~/core/events'
 export const createCommunity = async (
   bundle: Pick<
     Amity.Community,
-    'displayName' | 'avatarFileId' | 'description' | 'isPublic' | 'isOfficial' | 'onlyAdminCanPost' | 'needApprovalOnPostCreation' | 'tags' | 'metadata'
+    | 'displayName'
+    | 'avatarFileId'
+    | 'description'
+    | 'isPublic'
+    | 'isOfficial'
+    | 'postSetting'
+    | 'tags'
+    | 'metadata'
   > & {
-    userIds?: string[]
-    categoryIds?: string[]
-    isUniqueDisplayName?: boolean
-  }) => {
-  const client = getActiveClient()
-  client.log('user/createCommunity', bundle)
-
-  const { data } = await client.http.post<Amity.CommunityPayload>(
-    '/api/v3/communities/', bundle,
-  )
-
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.community.didCreate', data)
-
-  const { communities } = data
-  return communities[0]
-}
+    userIds?: string[];
+    categoryIds?: string[];
+    isUniqueDisplayName?: boolean;
+  },
+): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient();
+  client.log('user/createCommunity', bundle);
+
+  const { data: payload } = await client.http.post<Amity.CommunityPayload>(
+    '/api/v3/communities/',
+    packCommunityPayload(bundle),
+  );
+
+  const data = unpackCommunityPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('community.created', data);
+
+  const { communities } = data;
+  return {
+    data: communities[0],
+    cachedAt,
+  };
+};

package/src/community/api/deleteCommunity.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { fireEvent } from '~/core/events'
-import { getCommunity } from './getCommunity'
+import { fireEvent } from '~/core/events';
+import { getCommunity } from './getCommunity';
 
 /**
  * ```js
@@ -19,17 +19,15 @@ import { getCommunity } from './getCommunity'
  */
 export const deleteCommunity = async (
   communityId: Amity.Community['communityId'],
-) => {
-  const client = getActiveClient()
-  client.log('community/deleteCommunity', communityId)
+): Promise<Amity.Community> => {
+  const client = getActiveClient();
+  client.log('community/deleteCommunity', communityId);
 
   // API-FIX: This endpoint has not been implemented yet.
-  await client.http.delete<{ success: boolean }>(
-    `/api/v3/communities/${communityId}`,
-  )
+  await client.http.delete<{ success: boolean }>(`/api/v3/communities/${communityId}`);
 
-  const deleted = await getCommunity(communityId)
-  fireEvent('v3.community.didDelete', { communities: [deleted] })
+  const deleted = await getCommunity(communityId);
+  fireEvent('community.deleted', { communities: [deleted.data] });
 
-  return deleted
-}
+  return deleted.data;
+};

package/src/community/api/getCommunities.ts

@@ -1,8 +1,9 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { unpackCommunityPayload } from '../utils';
 
 /**
  * ```js
@@ -19,23 +20,29 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const getCommunities = async (
-  communityIds: Amity.Community['communityId'][]
-) => {
-  const client = getActiveClient()
-  client.log('community/getCommunities', communityIds)
+  communityIds: Amity.Community['communityId'][],
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient();
+  client.log('community/getCommunities', communityIds);
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/list`,
-    { params: { communityIds } },
-  )
+    {
+      params: { communityIds },
+    },
+  );
+
+  const data = unpackCommunityPayload(payload);
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { communities } = data
-  return toRecord(communities)
-}
+  return {
+    data: data.communities,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
@@ -51,13 +58,24 @@ export const getCommunities = async (
  * @category Community API
  */
 getCommunities.locally = (
-  communityIds: Amity.Community['communityId'][]
-) => {
-  const client = getActiveClient()
-  client.log('community/getCommunities.locally', communityIds)
+  communityIds: Amity.Community['communityId'][],
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient();
+  client.log('community/getCommunities.locally', communityIds);
+
+  if (!client.cache) return;
+
+  const cached = communityIds
+    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+    .filter(Boolean);
+
+  const communities = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
-  const cached = pullFromCache('community', ...communityIds) ?? []
+  if (cached?.length < communityIds.length) return;
 
-  if (cached?.length === communityIds.length)
-    return toRecord(cached)
-}
+  return {
+    data: communities,
+    cachedAt: oldest.cachedAt,
+  };
+};