@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

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

@@ -0,0 +1,209 @@
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  comment11,
+  imageComment11,
+  textImageComment11,
+  textMentionComment11,
+  textWithParentComment11,
+  post11,
+  textCommentPayload,
+  imageCommentPayload,
+  textImageCommentPayload,
+  textCommentMentionPayload,
+  textCommentParentIdPayload,
+  file11,
+  user11,
+  user12,
+  post12,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { createComment } from '../createComment';
+
+const createTextCommentResponse = {
+  data: {
+    ...textCommentPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const createImageCommentResponse = {
+  data: {
+    ...imageCommentPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const createTextImageCommentResponse = {
+  data: {
+    ...textImageCommentPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const createTextMentionCommentResponse = {
+  data: {
+    ...textCommentMentionPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const createTextCommentParentIdResponse = {
+  data: {
+    ...textCommentParentIdPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const getPostResponse = {
+  data: post11,
+  cachedAt: 1673337034544,
+};
+
+const textCommentRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  data: {
+    text: 'test',
+  },
+};
+
+const textCommentParentIdRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  parentId: post12.postId,
+  data: {
+    text: 'test',
+  },
+};
+
+const imageCommentRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  attachments: [
+    {
+      type: 'image',
+      fileId: file11.fileId,
+    },
+  ],
+};
+
+const textImageCommentRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  data: {
+    text: 'test',
+  },
+  attachments: [
+    {
+      type: 'image',
+      fileId: file11.fileId,
+    },
+  ],
+};
+
+const textCommentWithMentionRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  data: {
+    text: 'test',
+  },
+  mentionees: [
+    {
+      type: 'user',
+      userIds: [user11._id, user12._id],
+    },
+  ],
+};
+
+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(createTextCommentResponse);
+
+    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(createImageCommentResponse);
+
+    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(createTextImageCommentResponse);
+
+    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(createTextMentionCommentResponse);
+
+    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(createTextCommentParentIdResponse);
+
+    const newComment = await createComment(textCommentParentIdRequestPayload);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      '/api/v3/comments',
+      textCommentParentIdRequestPayload,
+    );
+    expect(newComment.data).toEqual(textWithParentComment11);
+  });
+
+  // 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/updateComment.test.ts

@@ -0,0 +1,189 @@
+import { createComment } from '../createComment';
+import { updateComment } from '../updateComment';
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  comment11,
+  imageComment11,
+  textImageComment11,
+  textMentionComment11,
+  textCommentPayload,
+  imageCommentPayload,
+  textImageCommentPayload,
+  textCommentMentionPayload,
+  file11,
+  user11,
+  user12,
+  post11,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+const updateTextCommentResponse = {
+  data: {
+    ...textCommentPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const updateImageCommentResponse = {
+  data: {
+    ...imageCommentPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const updateTextMentionCommentResponse = {
+  data: {
+    ...textCommentMentionPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const updateTextImageCommentResponse = {
+  data: {
+    ...textImageCommentPayload,
+    files: [],
+    commentChildren: [],
+  },
+};
+
+const textCommentRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  data: {
+    text: 'test',
+  },
+};
+
+const textCommentWithMentionRequestPayload: Parameters<typeof createComment>[0] = {
+  ...textCommentRequestPayload,
+  mentionees: [
+    {
+      type: 'user',
+      userIds: [user11._id, user12._id],
+    },
+  ],
+};
+
+const textImageCommentRequestPayload: Parameters<typeof createComment>[0] = {
+  ...textCommentRequestPayload,
+  attachments: [
+    {
+      type: 'image',
+      fileId: file11.fileId,
+    },
+  ],
+};
+
+const imageCommentRequestPayload: Parameters<typeof createComment>[0] = {
+  referenceId: post11.postId,
+  referenceType: 'post',
+  attachments: [
+    {
+      type: 'image',
+      fileId: file11.fileId,
+    },
+  ],
+};
+
+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: updateTextCommentResponse,
+      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: updateTextMentionCommentResponse,
+      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: updateTextImageCommentResponse,
+      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: updateTextImageCommentResponse,
+      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: updateTextCommentResponse,
+      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: updateImageCommentResponse,
+      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();
+    }),
+  );
+});

package/src/comment/api/updateComment.ts

@@ -3,6 +3,9 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: comment.update_comment
+*/
 /**
  * ```js
  * import { updateComment } from '@amityco/ts-sdk'
@@ -43,3 +46,4 @@ export const updateComment = async (
     cachedAt,
   };
 };
+/* end_public_function */

package/src/comment/events/tests/onCommentCreated.test.ts

@@ -0,0 +1,27 @@
+import { client, comment11, textCommentPayload } from '~/utils/tests';
+import { onCommentCreated } from '../onCommentCreated';
+
+describe('onCommentCreated', () => {
+  test('it should call callback when comment have created', () => {
+    const callback = jest.fn();
+
+    const unsub = onCommentCreated(callback);
+    client.emitter.emit('comment.created', textCommentPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(comment11);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onCommentCreated(callback);
+    unsub();
+
+    client.emitter.emit('comment.created', textCommentPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/comment/events/tests/onCommentDeleted.test.ts

@@ -0,0 +1,27 @@
+import { client, comment11, textCommentPayload } from '~/utils/tests';
+import { onCommentDeleted } from '../onCommentDeleted';
+
+describe('onCommentDeleted', () => {
+  test('it should call callback when comment have created', () => {
+    const callback = jest.fn();
+
+    const unsub = onCommentDeleted(callback);
+    client.emitter.emit('comment.deleted', textCommentPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(comment11);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onCommentDeleted(callback);
+    unsub();
+
+    client.emitter.emit('comment.deleted', textCommentPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/comment/events/utils.ts

@@ -4,7 +4,7 @@ import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 export const createCommentEventSubscriber = (
-  event: keyof Amity.MqttCommentMessageEvents,
+  event: keyof Amity.MqttCommentEvents,
   callback: Amity.Listener<Amity.Comment>,
 ) => {
   const client = getActiveClient();

package/src/comment/observers/index.ts

@@ -1,2 +1,4 @@
 export * from './observeComments';
 export * from './observeComment';
+export * from './liveComment';
+export * from './liveComments';

package/src/comment/observers/liveComment.ts

@@ -0,0 +1,43 @@
+import { liveObject } from '~/utils/liveObject';
+import { getComment } from '../api';
+import {
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+  onCommentUnflagged,
+  onCommentUpdated,
+} from '../events';
+
+/**
+ * ```js
+ * import { liveComment } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsubscribe = liveComment(commentId, response => {
+ *   comment = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment 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 comment
+ *
+ * @category Comment Live Object
+ */
+export const liveComment = (
+  commentId: Amity.Comment['commentId'],
+  callback: Amity.LiveObjectCallback<Amity.Comment>,
+): Amity.Unsubscriber => {
+  return liveObject(commentId, callback, 'commentId', getComment, [
+    onCommentDeleted,
+    onCommentFlagged,
+    onCommentReactionAdded,
+    onCommentReactionRemoved,
+    onCommentUnflagged,
+    onCommentUpdated,
+  ]);
+};