@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,52 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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;
-  }
-}