@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/src/comment/api/queryComments.ts

@@ -1,20 +1,17 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import {
-  decoratePayload,
-  filterByPropEquality,
-  sortBySegmentNumber,
-  toPage,
-  toToken,
-} from '~/core/query'
-
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+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'
- * const comments = await queryComments({ postId })
+ * const comments = await queryComments({ referenceType: 'post', referenceId: 'foo' })
  * ```
  *
  * Queries a paginable list of {@link Amity.Comment} objects
@@ -25,52 +22,64 @@ import { toRecord } 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
-}) => {
-  const client = getActiveClient()
-  client.log('comment/queryComments', 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, ...params } = query
+  const { page = { limit: 10 }, includeDeleted, ...params } = query;
 
-  const filterByParentId = query.parentId !== undefined
+  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, ...response } = data
+  const { paging, ...payload } = data;
+  const { comments } = payload;
+
+  const cachedAt = client.cache && Date.now();
 
-  decoratePayload(response as unknown as Record<string, Object[]>)
-  ingestInCache(response as unknown as Record<string, Object[]>)
+  if (client.cache) {
+    ingestInCache(payload as Amity.CommentPayload, { cachedAt });
 
-  const prevPage = toPage(paging.previous)
-  const nextPage = toPage(paging.next)
+    const cacheKey = [
+      'comment',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging });
+  }
 
-  const { comments } = response
-  return { data: toRecord(comments), prevPage, nextPage }
-}
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: comments, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
 
 /**
  * ```js
  * import { queryComments } from '@amityco/ts-sdk'
- * const comments = queryComments.locally({ postId })
+ * const comments = queryComments.locally({ referenceType: 'post', referenceId: 'foo' })
  * ```
  *
  * Queries a paginable list of {@link Amity.Comment} objects from cache
@@ -82,88 +91,30 @@ export const queryComments = async (query: {
  */
 queryComments.locally = (
   query: Parameters<typeof queryComments>[0],
-) => {
-  const client = getActiveClient()
-  client.log('post/queryComments.locally', query)
-
-  const {
-    referenceId,
-    referenceType,
-    parentId,
-    isDeleted,
-    page = { before: 0, limit: 5 },
-  } = query
-
-  if (isNaN(page.after!) && isNaN(page.before!))
-    page.before = 0;
-
-  if (isNaN(page.limit))
-    page.limit = 5
-
-  let comments: Amity.Comment[] = pullFromCache('comment') ?? []
-
-  // no cache
-  if (!comments.length)
-    return
-
-  // filter
-  comments = filterByPropEquality(comments, 'referenceId', referenceId)
-  comments = filterByPropEquality(comments, 'referenceType', referenceType)
-  comments = filterByPropEquality(comments, 'parentId', parentId)
-  comments = filterByPropEquality(comments, 'isDeleted', isDeleted)
-
-  // no interesting cache
-  if (!comments.length)
-    return
-
-  // sort
-  comments = comments.sort(sortBySegmentNumber)
-
-  // paging
-  // API-FIX we can't reuse proper page because the message page is done
-  // by segmentNumber which is sadly unique to the entire platform.
-  // this part is copied and adapted from sliceByPaging function
-
-  const afterIndex = !isNaN(page.after!)
-    ? comments.findIndex(({ segmentNumber }) => segmentNumber === page.after! + 1)
-    : 0
-
-  const beforeIndex = !isNaN(page.before!) && page.before !== 0
-    ? comments.findIndex(({ segmentNumber }) => segmentNumber === page.before! - 1) + 1
-    : comments.length
-
-  if (afterIndex < 0 || beforeIndex < 0)
-    return
-
-  let slice = comments.slice(
-    afterIndex !== -1 ? afterIndex : 0,
-    beforeIndex !== -1 ? beforeIndex : undefined,
-  )
-
-  // nothing left after slicing
-  if (!slice.length)
-    return
-
-  if (!isNaN(page.after!) && !isNaN(page.before!)) {
-    // do nothing
-  } else if (!isNaN(page.after!)) {
-    slice = slice.slice(0, page.limit)
-  } else if (!isNaN(page.before!)) {
-    slice = slice.slice(-page.limit)
-  }
+): Amity.Cached<Amity.Paged<Amity.Comment>> | undefined => {
+  const client = getActiveClient();
+  client.log('comment/queryComments.locally', query);
 
-  for (let i = 0; i < slice.length - 1; i++)
-    if (slice[i].segmentNumber !== slice[i + 1].segmentNumber - 1)
-      return
+  if (!client.cache) return;
 
-  const prevPage = slice[0].segmentNumber > 1
-    ? { before: slice[0].segmentNumber, limit: page.limit }
-    : undefined
+  const { page = { limit: 10 }, ...params } = query;
 
-  const nextPage = {
-    after: slice[slice.length - 1].segmentNumber,
-    limit: page.limit,
-  }
+  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;
+
+  const comments: Amity.Comment[] = data.comments
+    .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-  return { data: toRecord(slice), nextPage, prevPage }
-}
+  return comments.length === data?.comments?.length
+    ? { data: comments, cachedAt, prevPage, nextPage }
+    : 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);
+  });
+});

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

@@ -0,0 +1,147 @@
+import { queryComments } from '../queryComments';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  textCommentPayload,
+  imageCommentPayload,
+  post11,
+  textCommentResponse,
+  imageCommentResponse,
+  textAndImageCommentMixedPayload,
+  textCommentRequestPayload,
+  comment12,
+  comment12Payload,
+  deletedCommentPayload,
+  deletedCommentResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+type mockParamAndResponse = {
+  query: Amity.QueryComments;
+  response: Amity.Comment[];
+};
+
+const queryParams: mockParamAndResponse = {
+  query: {
+    referenceType: 'post',
+    referenceId: post11.postId,
+  },
+  response: textCommentPayload.comments,
+};
+
+const queryImageOnly: mockParamAndResponse = {
+  query: {
+    ...queryParams.query,
+    dataTypes: {
+      values: ['image'],
+      matchType: 'exact',
+    },
+  },
+  response: imageCommentPayload.comments,
+};
+
+const queryImageAny: mockParamAndResponse = {
+  query: {
+    ...queryParams.query,
+    dataTypes: {
+      values: ['image'],
+      matchType: 'any',
+    },
+  },
+  response: textAndImageCommentMixedPayload.comments,
+};
+
+const queryWithParentId: mockParamAndResponse = {
+  query: {
+    ...queryParams.query,
+    parentId: comment12.parentId,
+  },
+  response: comment12Payload.comments,
+};
+
+const deletedComment: mockParamAndResponse = {
+  query: {
+    ...queryParams.query,
+    includeDeleted: true,
+  },
+  response: deletedCommentPayload.comments,
+};
+
+describe('queryComments', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const testCase: [string, object, Amity.QueryComments, Amity.Comment[]][] = [
+    [
+      // integration_test_id: 0be48975-be6d-4199-bec0-af186af444d3
+      'Should return valid comment when user query with valid query',
+      textCommentResponse,
+      queryParams.query,
+      queryParams.response,
+    ],
+    [
+      // integration_test_id: 4550e036-53d0-4f35-b83f-9edc10f1c974
+
+      'Should return only valid image comment types when user query with dataType exact image',
+      imageCommentResponse,
+      queryImageOnly.query,
+      queryImageOnly.response,
+    ],
+    [
+      // integration_test_id: 03056892-251f-4a85-a9bf-f9978c1912e5
+      'Should return only valid deleted comment list when user query with isDeleted=true',
+      deletedCommentResponse,
+      deletedComment.query,
+      deletedComment.response,
+    ],
+    [
+      // integration_test_id: 2f68da78-7738-4371-ae72-b6a4ff043404
+
+      'Should return only valid mixed types comment list when user query with dataType any image',
+      {
+        data: {
+          ...textAndImageCommentMixedPayload,
+          paging: {},
+        },
+      },
+      queryImageAny.query,
+      queryImageAny.response,
+    ],
+    [
+      // integration_test_id: 8207d436-a800-4224-8fb0-a46c05f7d11e
+      'Should return only valid mixed types comment list when user query with parent_id',
+      {
+        data: {
+          ...comment12Payload,
+          paging: {},
+        },
+      },
+      queryWithParentId.query,
+      queryWithParentId.response,
+    ],
+  ];
+
+  test.each(testCase)('%s', async (title, mockResponse, query, expectResult) => {
+    client.http.get = jest.fn().mockResolvedValueOnce(mockResponse);
+    const result = await queryComments(query);
+    expect(result.data).toEqual(expectResult);
+  });
+
+  const errorCase: [string, number, Amity.QueryComments][] = [
+    [
+      // integration_test_id: 2719d77f-177a-401f-864f-ef0f0804cc24
+      'Should return error 400400 when query with wrong post_id', // title
+      Amity.ServerError.ITEM_NOT_FOUND, // errorCode
+      textCommentRequestPayload, // payload
+    ],
+  ];
+
+  test.each(errorCase)('%s', async (title, errorCode, payload) => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(new ASCApiError('not found!', errorCode, Amity.ErrorLevel.ERROR));
+    await expect(queryComments(payload)).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,118 @@
+import { createComment } from '../createComment';
+import { updateComment } from '../updateComment';
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  comment11,
+  imageComment11,
+  textImageComment11,
+  textMentionComment11,
+  imageCommentResponse,
+  textCommentResponse,
+  textImageCommentResponse,
+  textMentionCommentResponse,
+  imageCommentRequestPayload,
+  textCommentRequestPayload,
+  textCommentWithMentionRequestPayload,
+  textImageCommentRequestPayload,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+describe('updateComment', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // functional and logic test
+  [
+    {
+      // integration_test_id: 1f0c74da-863e-44eb-acf1-3de57b1a0e79
+      title: 'update comment with valid data and return a new data',
+      mockRequest: textCommentResponse,
+      mockFunction: textCommentRequestPayload,
+      expectResult: comment11,
+      extraCase: [],
+    },
+    {
+      // integration_test_id: 72550ea2-2943-4708-bc36-dd2b4fcf44b7
+      title: 'update text comment with mention and returns the new valid comment',
+      mockRequest: textMentionCommentResponse,
+      mockFunction: textCommentWithMentionRequestPayload,
+      expectResult: textMentionComment11,
+      extraCase: [],
+    },
+    {
+      // integration_test_id: 9df2ff6c-81b7-4bdd-bcd2-33d9752735ed
+      title: 'update an image + text comment and returns the new valid comment',
+      mockRequest: textImageCommentResponse,
+      mockFunction: textImageCommentRequestPayload,
+      expectResult: textImageComment11,
+      extraCase: [],
+    },
+    {
+      // integration_test_id: 75c77684-09f3-442e-8089-6d37e2182a65
+      title: 'add image to existing comment and returns the new valid comment',
+      mockRequest: textImageCommentResponse,
+      mockFunction: textImageCommentRequestPayload,
+      expectResult: textImageComment11,
+      extraCase: [],
+    },
+    {
+      // integration_test_id: b50d7783-ab5e-4473-be3b-08ffe8b5142a
+      title: 'remove image from existing comment and returns the new valid comment',
+      mockRequest: textCommentResponse,
+      mockFunction: textCommentRequestPayload,
+      expectResult: comment11,
+      extraCase: [{ attachments: [] }],
+    },
+    {
+      // integration_test_id: f31daa63-7214-400a-a7a1-d9b00d37137e
+      title: 'remove text from existing media comment and returns the new valid comment',
+      mockRequest: imageCommentResponse,
+      mockFunction: imageCommentRequestPayload,
+      expectResult: imageComment11,
+      extraCase: [{ data: { text: '' } }],
+    },
+  ].forEach(({ title, mockRequest, mockFunction, expectResult, extraCase }) =>
+    it(title, async () => {
+      client.http.put = jest.fn().mockResolvedValueOnce(mockRequest);
+
+      const newComment = await updateComment(comment11.commentId, mockFunction);
+
+      expect(getActiveClient().http.put).toHaveBeenCalledWith(
+        `/api/v3/comments/${comment11.commentId}`,
+        mockFunction,
+      );
+      expect(newComment.data).toEqual(expectResult);
+
+      extraCase.forEach(value => {
+        expect(newComment.data).toEqual(expect.objectContaining(value));
+      });
+    }),
+  );
+
+  // Failed case
+  [
+    {
+      // integration_test_id: f2c24783-733e-4a4a-90c4-b518a8d584a1
+      title: 'edit text comment with invalid comment_id and returns 400400 error',
+      errorCode: Amity.ServerError.ITEM_NOT_FOUND,
+      payload: textCommentRequestPayload,
+    },
+    {
+      // integration_test_id: 2f556a4c-2148-4d59-b07e-f415d7c8928c
+      title: 'edit text comment which not own by current user and returns 400301 error',
+      errorCode: Amity.ServerError.PERMISSION_DENIED,
+      payload: textCommentRequestPayload,
+    },
+  ].forEach(({ title, errorCode, payload }) =>
+    it(title, async () => {
+      client.http.put = jest
+        .fn()
+        .mockRejectedValueOnce(new ASCApiError('not found!', errorCode, Amity.ErrorLevel.ERROR));
+
+      await expect(createComment(payload)).rejects.toThrow();
+    }),
+  );
+});