@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/commentRepository/internalApi/tests/hardDeleteComment.test.ts

@@ -0,0 +1,52 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  generatePost,
+  generateComment,
+} from '~/utils/tests';
+import { disableCache, enableCache } from '~/cache/api';
+
+import { hardDeleteComment } from '../hardDeleteComment';
+
+const getPostResponse = {
+  data: generatePost,
+  cachedAt: 1673337034544,
+};
+
+jest.mock('~/postRepository/api/getPost', () => ({
+  getPost: jest.fn(() => Promise.resolve(getPostResponse)),
+}));
+
+describe('hardDeleteComment', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  /*
+   * this is the only test required as the rest should be tested in
+   * deleteComment.test.ts
+   */
+  test('it should call the api with the correct param', async () => {
+    const mockApi = jest.fn().mockResolvedValue({ data: {} });
+    const commentId = 'comment-id';
+    const expected = { params: { permanent: true, commentId } };
+
+    // mock get comment
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        comments: [{ ...generateComment(), commentId: 'comment-id' }],
+        commentChildren: [],
+      },
+    });
+    client.http.delete = mockApi;
+
+    await hardDeleteComment(commentId);
+
+    const recieved = mockApi.mock.lastCall[1];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});

package/src/commentRepository/internalApi/tests/queryComments.test.ts

@@ -0,0 +1,147 @@
+import {
+  client,
+  comment12,
+  comment12Payload,
+  connectClient,
+  deletedCommentPayload,
+  deletedCommentResponse,
+  disconnectClient,
+  imageCommentPayload,
+  imageCommentResponse,
+  post11,
+  textAndImageCommentMixedPayload,
+  textCommentPayload,
+  textCommentRequestPayload,
+  textCommentResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { queryComments } from '../queryComments';
+
+type mockParamAndResponse = {
+  query: Amity.QueryComments;
+  response: Amity.InternalComment[];
+};
+
+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.InternalComment[]][] = [
+    [
+      // 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/commentRepository/internalApi/tests/softDeleteComment.test.ts

@@ -0,0 +1,52 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  generatePost,
+  generateComment,
+} from '~/utils/tests';
+import { disableCache, enableCache } from '~/cache/api';
+
+import { softDeleteComment } from '../softDeleteComment';
+
+const getPostResponse = {
+  data: generatePost,
+  cachedAt: 1673337034544,
+};
+
+jest.mock('~/postRepository/api/getPost', () => ({
+  getPost: jest.fn(() => Promise.resolve(getPostResponse)),
+}));
+
+describe('softDeleteComment', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  /*
+   * this is the only test required as the rest should be tested in
+   * deleteComment.test.ts
+   */
+  test('it should call the api with the correct param', async () => {
+    const mockApi = jest.fn().mockResolvedValue({ data: {} });
+    const commentId = 'comment-id';
+    const expected = { params: { permanent: false, commentId } };
+
+    // mock get comment
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        comments: [{ ...generateComment(), commentId: 'comment-id' }],
+        commentChildren: [],
+      },
+    });
+    client.http.delete = mockApi;
+
+    await softDeleteComment(commentId);
+
+    const recieved = mockApi.mock.lastCall[1];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});

package/src/commentRepository/internalApi/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/commentRepository/internalApi/unflagComment.ts

@@ -0,0 +1,24 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { fireEvent } from '~/core/events';
+
+export const unflagComment = async (
+  commentId: Amity.InternalComment['commentId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('comment/unflagComment', commentId);
+
+  const { data: payload } = await client.http.delete<Amity.CommentPayload>(
+    `/api/v3/comments/${encodeURIComponent(commentId)}/unflag`,
+  );
+
+  if (client.cache) {
+    ingestInCache(payload);
+  }
+
+  fireEvent('comment.unflagged', payload);
+
+  return !!payload;
+};

package/src/commentRepository/internalApi/updateComment.ts

@@ -0,0 +1,28 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+export const updateComment = async (
+  commentId: Amity.InternalComment['commentId'],
+  patch: Patch<Amity.InternalComment, 'data' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.InternalComment>> => {
+  const client = getActiveClient();
+  client.log('user/updateComment', patch);
+
+  const { data } = await client.http.put<Amity.CommentPayload>(
+    `/api/v3/comments/${encodeURIComponent(commentId)}`,
+    patch,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('comment.updated', data);
+
+  const { comments } = data;
+  return {
+    data: comments.find(comment => comment.commentId === commentId)!,
+    cachedAt,
+  };
+};

package/src/commentRepository/observers/getComment.ts

@@ -0,0 +1,55 @@
+import { liveObject } from '~/utils/liveObject';
+import { pullFromCache } from '~/cache/api';
+import { getComment as _getComment } from '../internalApi/getComment';
+import {
+  onCommentCreated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+  onCommentUnflagged,
+  onCommentUpdated,
+} from '../events';
+import { onCommentDeleteLocal } from '../events/onCommentDeletedLocal';
+import { onLocalCommentReactionAdded } from '../events/onLocalCommentReactionAdded';
+import { onLocalCommentReactionRemoved } from '../events/onLocalCommentReactionRemoved';
+
+/* begin_public_function
+  id: comment.get
+*/
+/**
+ * ```js
+ * import { CommentRepository } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsub = CommentRepository.getComment(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 getComment = (
+  commentId: Amity.Comment['commentId'],
+  callback: Amity.LiveObjectCallback<Amity.Comment>,
+): Amity.Unsubscriber => {
+  return liveObject(commentId, callback, 'commentId', _getComment, [
+    onCommentDeleteLocal,
+    onCommentDeleted,
+    onCommentFlagged,
+    onCommentReactionAdded,
+    onCommentReactionRemoved,
+    onCommentUnflagged,
+    onCommentUpdated,
+    onLocalCommentReactionAdded,
+    onLocalCommentReactionRemoved,
+  ]);
+};
+/* end_public_function */

package/src/commentRepository/observers/getComments/CommentLiveCollectionController.ts

@@ -0,0 +1,170 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CommentPaginationController } from './CommentPaginationController';
+import { CommentQueryStreamController } from './CommentQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '~/commentRepository/events';
+import { filterByPropEquality, sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { isNonNullable } from '~/utils';
+import { EnumCommentActions } from './enums';
+import { LinkedObject } from '~/utils/linkedObject';
+import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+import { onCommentCreatedLocal } from '~/commentRepository/events/onCommentCreatedLocal';
+import { onCommentDeleteLocal } from '~/commentRepository/events/onCommentDeletedLocal';
+import { onLocalCommentReactionAdded } from '~/commentRepository/events/onLocalCommentReactionAdded';
+import { onLocalCommentReactionRemoved } from '~/commentRepository/events/onLocalCommentReactionRemoved';
+
+export class CommentLiveCollectionController extends LiveCollectionController<
+  'comment',
+  Amity.CommentLiveCollection,
+  Amity.Comment,
+  CommentPaginationController
+> {
+  private queryStreamController: CommentQueryStreamController;
+
+  private query: Amity.CommentLiveCollection;
+
+  constructor(
+    query: Amity.CommentLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['comments', 'collection', queryStreamId];
+    const paginationController = new CommentPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CommentQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommentPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommentPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'comment'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
+      { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
+      { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
+      { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
+      { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+      { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
+      { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
+      { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+      { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+      { fn: onLocalCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+      { fn: onLocalCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalComment>(['comment', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    ).map(LinkedObject.comment);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.InternalComment[]) {
+    let comments = data;
+
+    if (!this.query.includeDeleted) {
+      comments = filterByPropEquality(comments, 'isDeleted', false);
+    }
+
+    if (this.query.parentId) {
+      comments = comments.filter(comment => comment.parentId === this.query.parentId);
+    }
+
+    if (typeof this.query.hasFlag === 'boolean') {
+      if (this.query.hasFlag) {
+        comments = comments.filter(comment => comment.hashFlag != null);
+      } else {
+        comments = comments.filter(comment => comment.hashFlag == null);
+      }
+    }
+
+    if (this.query.dataTypes) {
+      if (this.query.dataTypes.matchType === 'exact') {
+        comments = comments.filter(comment => {
+          const sortedDataTypesQueryValue = this.query.dataTypes?.values.sort() || [];
+          const sortedDataTypesCommentValue = comment.dataTypes?.sort() || [];
+
+          if (sortedDataTypesCommentValue.length !== sortedDataTypesQueryValue.length) {
+            return false;
+          }
+
+          return sortedDataTypesQueryValue.every(
+            (value, index) => value === sortedDataTypesCommentValue[index],
+          );
+        });
+      }
+      if (this.query.dataTypes.matchType === 'any') {
+        comments = comments.filter(comment =>
+          this.query.dataTypes?.values.some(value => comment.dataTypes?.includes(value)),
+        );
+      }
+    }
+
+    switch (this.query.sortBy) {
+      case 'firstCreated':
+        comments = comments.sort(sortByFirstCreated);
+        break;
+      case 'lastCreated':
+      default:
+        comments = comments.sort(sortByLastCreated);
+        break;
+    }
+
+    return comments;
+  }
+}

package/src/commentRepository/observers/getComments/CommentPaginationController.ts

@@ -0,0 +1,30 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+export class CommentPaginationController extends PaginationController<
+  'comment',
+  Amity.CommentLiveCollection
+> {
+  async getRequest(queryParams: Amity.CommentLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
+
+    const baseOptions = {
+      type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
+    };
+
+    const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.CommentPayload & Amity.Pagination>(
+      `/api/v3/comments`,
+      {
+        params: {
+          ...params,
+          isDeleted: inferIsDeleted(includeDeleted),
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}