@amityco/ts-sdk 0.0.1-ec24ce0.0 → 0.0.1-ec76bde.0

package/src/comment/api/deleteComment.ts

@@ -1,12 +1,17 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { dropFromCache } from '~/cache/api'
-import { upsertInCache } from '~/cache/api'
-import { fireEvent } from '~/core/events'
+import { upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
 
-import { getComment } from './getComment'
-import { getPost } from '~/post/api/getPost'
+import { getPost } from '~/post/api/getPost';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { scheduleTask } from '~/core/microtasks';
 
+import { getComment } from './getComment';
+
+/* begin_public_function
+  id: comment.soft_delete, comment.hard_delete
+*/
 /**
  * ```js
  * import { deleteComment } from '@amityco/ts-sdk'
@@ -23,39 +28,54 @@ import { getPost } from '~/post/api/getPost'
  */
 export const deleteComment = async (
   commentId: Amity.Comment['commentId'],
-  permanent: boolean = false,
+  permanent = false,
 ): Promise<Amity.Comment> => {
-  const client = getActiveClient()
-  client.log('comment/deleteComment', commentId)
+  const client = getActiveClient();
+  client.log('comment/deleteComment', commentId);
 
-  const comment = await getComment(commentId)
+  const comment = await getComment(commentId);
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
-    `/api/v4/comments/${encodeURIComponent(commentId)}`, {
+    `/api/v4/comments/${encodeURIComponent(commentId)}`,
+    {
       params: {
         commentId,
         permanent,
       },
     },
-  )
+  );
 
   // to support hard deletion
-  const deleted = { ...comment.data, isDeleted: true }
+  const deleted = { ...comment.data, isDeleted: true };
 
-  const post = await getPost(comment.data.referenceId)
+  const post = await getPost(comment.data.referenceId);
 
-  fireEvent('post.updated', { posts: [post.data] })
-  fireEvent('comment.deleted', { comments: [deleted] })
+  fireEvent('post.updated', {
+    posts: [post.data],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+  });
 
+  fireEvent('comment.deleted', {
+    comments: [deleted],
+    commentChildren: [],
+    files: [],
+    users: [],
+  });
 
   if (permanent) {
-    setTimeout(() => {
-      dropFromCache(['comment', 'get', commentId], true)
-    }, 0)
+    scheduleTask(() => pushToTombstone('comment', commentId));
   } else {
-    upsertInCache(['comment', 'get', commentId], {isDeleted: true})
+    upsertInCache(['comment', 'get', commentId], { isDeleted: true });
   }
 
-  return deleted
-}
+  return deleted;
+};
+/* end_public_function */

package/src/comment/api/getComment.ts

@@ -1,8 +1,14 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
+/* begin_public_function
+  id: comment.get
+*/
 /**
  * ```js
  * import { getComment } from '@amityco/ts-sdk'
@@ -18,10 +24,12 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @async
  */
 export const getComment = async (
-  commentId: Amity.Comment['commentId']
+  commentId: Amity.Comment['commentId'],
 ): Promise<Amity.Cached<Amity.Comment>> => {
-  const client = getActiveClient()
-  client.log('comment/getComment', commentId)
+  const client = getActiveClient();
+  client.log('comment/getComment', commentId);
+
+  isInTombstone('comment', commentId);
 
   let data: Amity.CommentPayload;
 
@@ -29,26 +37,27 @@ export const getComment = async (
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const response = await client.http.get<Amity.CommentPayload>(
       `/api/v3/comments/${encodeURIComponent(commentId)}`,
-    )
+    );
 
     data = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache(['comment', 'get', commentId], true)
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('comment', commentId);
     }
 
     throw error;
   }
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { comments } = data
+  const { comments } = data;
   return {
     data: comments.find(comment => comment.commentId === commentId)!,
     cachedAt,
-  }
-}
+  };
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -64,20 +73,19 @@ export const getComment = async (
  * @category Comment API
  */
 getComment.locally = (
-  commentId: Amity.Comment['commentId']
+  commentId: Amity.Comment['commentId'],
 ): Amity.Cached<Amity.Comment> | undefined => {
-  const client = getActiveClient()
-  client.log('comment/getComment.locally', commentId)
+  const client = getActiveClient();
+  client.log('comment/getComment.locally', commentId);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Comment>(['comment', 'get', commentId])
+  const cached = pullFromCache<Amity.Comment>(['comment', 'get', commentId]);
 
-  if (!cached)
-    return
+  if (!cached) return;
 
   return {
     data: cached.data,
     cachedAt: cached.cachedAt,
-  }
-}
+  };
+};

package/src/comment/api/getComments.ts

@@ -1,8 +1,11 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { pullFromCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: comment.get_by_ids
+*/
 /**
  * ```js
  * import { getComments } from '@amityco/ts-sdk'
@@ -20,25 +23,25 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
 export const getComments = async (
   commentIds: Amity.Comment['commentId'][],
 ): Promise<Amity.Cached<Amity.Comment[]>> => {
-  const client = getActiveClient()
-  client.log('comment/getComments', commentIds)
+  const client = getActiveClient();
+  client.log('comment/getComments', commentIds);
 
-  const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId))
+  const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.CommentPayload>(
-    `/api/v3/comments/list`,
-    { params: { commentIds: encodedCommentIds } },
-  )
+  const { data } = await client.http.get<Amity.CommentPayload>(`/api/v3/comments/list`, {
+    params: { commentIds: encodedCommentIds },
+  });
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   return {
     data: data.comments,
-    cachedAt
-  }
-}
+    cachedAt,
+  };
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -54,25 +57,24 @@ export const getComments = async (
  * @category Comment API
  */
 getComments.locally = (
-  commentIds: Amity.Comment['commentId'][]
+  commentIds: Amity.Comment['commentId'][],
 ): Amity.Cached<Amity.Comment[]> | undefined => {
-  const client = getActiveClient()
-  client.log('comment/getComments.locally', commentIds)
+  const client = getActiveClient();
+  client.log('comment/getComments.locally', commentIds);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
   const cached = commentIds
     .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
-    .filter(Boolean)
+    .filter(Boolean);
 
-  const comments = cached.map(({ data }) => data)
-  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+  const comments = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
-  if (cached?.length < commentIds.length)
-    return
+  if (cached?.length < commentIds.length) return;
 
   return {
     data: comments,
     cachedAt: oldest.cachedAt,
-  }
-}
+  };
+};

package/src/comment/api/index.ts

@@ -1,7 +1,7 @@
-export * from './queryComments'
-export * from './getComments'
-export * from './getComment'
+export * from './queryComments';
+export * from './getComments';
+export * from './getComment';
 
-export * from './createComment'
-export * from './updateComment'
-export * from './deleteComment'
+export * from './createComment';
+export * from './updateComment';
+export * from './deleteComment';

package/src/comment/api/queryComments.ts

@@ -1,15 +1,13 @@
-import { getActiveClient } from '~/client/api'
-
-import {
-  sortBySegmentNumber,
-  toPage,
-  toToken,
-} from '~/core/query'
-import { pullFromCache, pushToCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { getResolver } from '~/core/model'
+import { getActiveClient } from '~/client/api';
 
+import { toPage, toToken } from '~/core/query';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
 
+/* begin_public_function
+  id: comment.query
+*/
 /**
  * ```js
  * import { queryComments } from '@amityco/ts-sdk'
@@ -24,53 +22,59 @@ import { getResolver } from '~/core/model'
  * @category Comment API
  * @async
  */
-export const queryComments = async (query: {
-  referenceType: Amity.Comment['referenceType'],
-  referenceId: Amity.Comment['referenceId'],
-  parentId?: Amity.Comment['commentId'] | null
-  hasFlag?: boolean
-  isDeleted?: Amity.Comment['isDeleted']
-  page?: Amity.Page
-}): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
-  const client = getActiveClient()
-  client.log('comment/queryComments', query)
-
-  const { page = { limit: 10 }, ...params } = query
-
+export const queryComments = async (
+  query: Amity.QueryComments,
+): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
+  const client = getActiveClient();
+  client.log('comment/queryComments', query);
+
+  const { page = { limit: 10 }, includeDeleted, ...params } = query;
+
+  const options = {
+    type: params.sortBy ? 'pagination' : undefined,
+    token: toToken(page, params.sortBy ? 'skiplimit' : 'afterbefore'),
+  };
   // const filterByParentId = query.parentId !== undefined
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.CommentPayload>>>(
-  const { data } = await client.http.get<Amity.CommentPayload & Amity.Pagination>(`/api/v3/comments`, {
-    params: {
-      ...params,
-      //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
-      options: {
-        token: toToken(page, 'afterbefore'),
+  const { data } = await client.http.get<Amity.CommentPayload & Amity.Pagination>(
+    `/api/v3/comments`,
+    {
+      params: {
+        ...params,
+        isDeleted: includeDeleted === false ? false : undefined,
+        //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
+        options,
       },
     },
-  })
+  );
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, comments } = unwrapPayload(data)
-  const { paging, ...payload } = data
-  const { comments } = payload
+  const { paging, ...payload } = data;
+  const { comments } = payload;
 
-  const cachedAt = client.cache && Date.now()
+  const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.CommentPayload, { cachedAt })
-
-    const cacheKey = ['comment', 'query', { ...params, options: { ...page } } as Amity.Serializable]
-    pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging })
+    ingestInCache(payload as Amity.CommentPayload, { cachedAt });
+
+    const cacheKey = [
+      'comment',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging });
   }
 
-  const nextPage = toPage(paging.next)
-  const prevPage = toPage(paging.previous)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  return { data: comments, cachedAt, prevPage, nextPage }
-}
+  return { data: comments, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -88,28 +92,29 @@ export const queryComments = async (query: {
 queryComments.locally = (
   query: Parameters<typeof queryComments>[0],
 ): Amity.Cached<Amity.Paged<Amity.Comment>> | undefined => {
-  const client = getActiveClient()
-  client.log('comment/queryComments.locally', query)
+  const client = getActiveClient();
+  client.log('comment/queryComments.locally', query);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query
+  const { page = { limit: 10 }, ...params } = query;
 
-  const queryKey = ['comment', 'query', { ...params, options: { ...page }} as Amity.Serializable];
-  const { data, cachedAt } = pullFromCache<{comments: Pick<Amity.Comment, 'commentId'>[]} & Amity.Pagination>(queryKey) ?? {}
+  const queryKey = ['comment', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ comments: Pick<Amity.Comment, 'commentId'>[] } & Amity.Pagination>(queryKey) ??
+    {};
 
-  if (!data?.comments.length)
-    return
+  if (!data?.comments.length) return;
 
   const comments: Amity.Comment[] = data.comments
     .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
     .filter(Boolean)
-    .map(({ data }) => data)
+    .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous)
-  const nextPage = toPage(data?.paging.next)
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
   return comments.length === data?.comments?.length
     ? { data: comments, cachedAt, prevPage, nextPage }
-    : undefined
-}
+    : undefined;
+};

package/src/comment/api/tests/createComment.test.ts

@@ -0,0 +1,114 @@
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  comment11,
+  imageComment11,
+  textImageComment11,
+  textMentionComment11,
+  comment12,
+  post11,
+  imageCommentResponse,
+  textCommentParentIdResponse,
+  textCommentResponse,
+  textImageCommentResponse,
+  textMentionCommentResponse,
+  imageCommentRequestPayload,
+  textCommentParentIdRequestPayload,
+  textCommentRequestPayload,
+  textCommentWithMentionRequestPayload,
+  textImageCommentRequestPayload,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { createComment } from '../createComment';
+
+const getPostResponse = {
+  data: post11,
+  cachedAt: 1673337034544,
+};
+
+jest.mock('~/post/api/getPost', () => ({
+  getPost: jest.fn(() => Promise.resolve(getPostResponse)),
+}));
+
+describe('createComment', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: 2f83eabc-46db-43d8-89c6-1b5339d6a273
+  it('creates a text comment and returns the new valid comment', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(textCommentResponse);
+
+    const newComment = await createComment(textCommentRequestPayload);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      '/api/v3/comments',
+      textCommentRequestPayload,
+    );
+    expect(newComment.data).toEqual(comment11);
+  });
+
+  // integration_test_id: 81e7d5bc-6881-4f9b-b8d4-deb5fe67200c
+  it('creates a image comment and returns the new valid comment', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(imageCommentResponse);
+
+    const newComment = await createComment(imageCommentRequestPayload);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      '/api/v3/comments',
+      imageCommentRequestPayload,
+    );
+    expect(newComment.data).toEqual(imageComment11);
+  });
+
+  // integration_test_id: 015838a8-3267-4253-920a-9ae83197cf22
+  it('creates an image + text comment and returns the new valid comment', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(textImageCommentResponse);
+
+    const newComment = await createComment(textImageCommentRequestPayload);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      '/api/v3/comments',
+      textImageCommentRequestPayload,
+    );
+    expect(newComment.data).toEqual(textImageComment11);
+  });
+
+  // integration_test_id: c2285355-f3b6-4e22-926b-11bcf0393161
+  it('creates text comment with mention and returns the new valid comment', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(textMentionCommentResponse);
+
+    const newComment = await createComment(textCommentWithMentionRequestPayload);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      '/api/v3/comments',
+      textCommentWithMentionRequestPayload,
+    );
+    expect(newComment.data).toEqual(textMentionComment11);
+  });
+
+  // integration_test_id: cb1bfe11-c11a-4324-aeb5-03370da820ad
+  it('creates text comment with parent_id and returns the new valid comment', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(textCommentParentIdResponse);
+
+    const newComment = await createComment(textCommentParentIdRequestPayload);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      '/api/v3/comments',
+      textCommentParentIdRequestPayload,
+    );
+    expect(newComment.data).toEqual(comment12);
+  });
+
+  // integration_test_id: 7f411488-abba-46d1-8707-a1d8adbd7242
+  it('creates text comment with invalid parent_id and returns 400400 error', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(createComment(textCommentParentIdRequestPayload)).rejects.toThrow();
+  });
+});

package/src/comment/api/tests/getComments.test.ts

@@ -0,0 +1,36 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, comment11, user11 } from '~/utils/tests';
+import { getComments } from '../getComments';
+
+const apiResponse = {
+  data: {
+    comments: [comment11],
+    commentChildren: [],
+    users: [user11],
+    files: [],
+  },
+};
+
+const commentsListResponse = {
+  data: [comment11],
+};
+
+describe('getComments', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the comments from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(apiResponse);
+    const { data } = await getComments([comment11.commentId]);
+    expect(data).toEqual(commentsListResponse.data);
+  });
+
+  test('Should return comments from locally', () => {
+    const comments: ReturnType<typeof getComments.locally> = getComments.locally([
+      comment11.commentId,
+    ]);
+
+    expect(comments?.data).toEqual(commentsListResponse.data);
+  });
+});