@amityco/ts-sdk 0.0.1 → 6.0.0

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

@@ -0,0 +1,147 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  textCommentPayload,
+  imageCommentPayload,
+  post11,
+  textCommentResponse,
+  imageCommentResponse,
+  textAndImageCommentMixedPayload,
+  textCommentRequestPayload,
+  comment12,
+  comment12Payload,
+  deletedCommentPayload,
+  deletedCommentResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { queryComments } from '../queryComments';
+
+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();
+    }),
+  );
+});

package/src/comment/api/updateComment.ts

@@ -1,13 +1,15 @@
-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';
 
+/* begin_public_function
+  id: comment.update_comment
+*/
 /**
  * ```js
- * import { updateComment } from '@amityco/ts-sdk'
- * const updated = await updateComment(commentId, {
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const updated = await CommentRepository.updateComment(commentId, {
  *   data: { text: 'hello world' }
  * })
  * ```
@@ -23,19 +25,25 @@ import { fireEvent } from '~/core/events'
  */
 export const updateComment = async (
   commentId: Amity.Comment['commentId'],
-  patch: Patch<Amity.Comment, 'data' | 'metadata'>,
-) => {
-  const client = getActiveClient()
-  client.log('user/updateComment', patch)
+  patch: Patch<Amity.Comment, 'data' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Comment>> => {
+  const client = getActiveClient();
+  client.log('user/updateComment', patch);
 
   const { data } = await client.http.put<Amity.CommentPayload>(
-    `/api/v3/comments/${commentId}`, patch,
-  )
+    `/api/v3/comments/${encodeURIComponent(commentId)}`,
+    patch,
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.comment.didUpdate', data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { comments } = data
-  return comments.find(comment => comment.commentId === commentId)!
-}
+  fireEvent('comment.updated', data);
+
+  const { comments } = data;
+  return {
+    data: comments.find(comment => comment.commentId === commentId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/comment/events/index.ts

@@ -1,3 +1,9 @@
-export * from './onCommentCreated'
-export * from './onCommentUpdated'
-export * from './onCommentDeleted'
+export * from './onCommentCreated';
+export * from './onCommentUpdated';
+export * from './onCommentDeleted';
+
+export * from './onCommentFlagged';
+export * from './onCommentUnflagged';
+
+export * from './onCommentReactionAdded';
+export * from './onCommentReactionRemoved';

package/src/comment/events/onCommentCreated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createCommentEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been created
+ * Fired when a {@link Amity.Comment} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Comment Events
  */
-export const onCommentCreated = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onCommentCreated',
-    'v3.comment.didCreate',
-    filter
-  )
-}
+export const onCommentCreated = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.created', callback);

package/src/comment/events/onCommentDeleted.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createCommentEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been deleted
+ * Fired when a {@link Amity.Comment} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Comment Events
  */
-export const onCommentDeleted = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onCommentDeleted',
-    'v3.comment.didDelete',
-    filter
-  )
-}
+export const onCommentDeleted = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.deleted', callback);

package/src/comment/events/onCommentFlagged.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentFlagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentFlagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentFlagged = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.flagged', callback);

package/src/comment/events/onCommentReactionAdded.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentReactionAdded = (
+  callback: Amity.Listener<Amity.Comment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+    if (!client.cache) {
+      callback(payload.comments[0]);
+    } else {
+      preparePayloadForCache('comment.addReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload);
+
+      const comment = pullFromCache<Amity.Comment>([
+        'comment',
+        'get',
+        payload.comments[0].commentId,
+      ])!;
+
+      callback(comment.data);
+    }
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/comment/events/onCommentReactionRemoved.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentReactionRemoved = (
+  callback: Amity.Listener<Amity.Comment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+    if (!client.cache) {
+      callback(payload.comments[0]);
+    } else {
+      preparePayloadForCache('comment.removeReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload);
+
+      const comment = pullFromCache<Amity.Comment>([
+        'comment',
+        'get',
+        payload.comments[0].commentId,
+      ])!;
+
+      callback(comment.data);
+    }
+  };
+
+  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};

package/src/comment/events/onCommentUnflagged.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentUnflagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentUnflagged = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.unflagged', callback);

package/src/comment/events/onCommentUpdated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createCommentEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * Fired when a {@link Amity.Comment} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Comment Events
  */
-export const onCommentUpdated = <T extends Amity.CommentContentType>(
-  callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onCommentUpdated',
-    'v3.comment.didUpdate',
-    filter
-  )
-}
+export const onCommentUpdated = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.updated', callback);

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();
+  });
+});