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

package/src/commentRepository/internalApi/createComment.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { getPost } from '~/postRepository/api/getPost';
+
+export const createComment = async (
+  bundle: Pick<
+    Amity.Comment<Amity.CommentContentType>,
+    | 'data'
+    | 'referenceType'
+    | 'referenceId'
+    | 'parentId'
+    | 'metadata'
+    | 'mentionees'
+    | 'attachments'
+  >,
+): Promise<Amity.Cached<Amity.InternalComment>> => {
+  const client = getActiveClient();
+  client.log('comment/createComment', bundle);
+
+  const { data } = await client.http.post<Amity.CommentPayload>('/api/v3/comments', bundle);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const post = await getPost(bundle.referenceId);
+
+  fireEvent('local.post.updated', {
+    posts: [post.data],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+    videoStreamings: [],
+  });
+
+  fireEvent('local.comment.created', data);
+
+  const { comments } = data;
+  return {
+    data: comments[0],
+    cachedAt,
+  };
+};

package/src/commentRepository/internalApi/deleteComment.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+import { getPost } from '~/postRepository/api/getPost';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { scheduleTask } from '~/core/microtasks';
+
+import { getComment } from './getComment';
+
+export const deleteComment = async (
+  commentId: Amity.InternalComment['commentId'],
+  permanent = false,
+): Promise<Amity.InternalComment> => {
+  const client = getActiveClient();
+
+  const comment = await getComment(commentId);
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v4/comments/${encodeURIComponent(commentId)}`,
+    {
+      params: {
+        commentId,
+        permanent,
+      },
+    },
+  );
+
+  // to support hard deletion
+  const deleted = { ...comment.data, isDeleted: true };
+
+  const post = await getPost(comment.data.referenceId);
+
+  fireEvent('local.post.updated', {
+    posts: [post.data],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+    videoStreamings: [],
+  });
+
+  fireEvent('local.comment.deleted', {
+    comments: [deleted],
+    commentChildren: [],
+    files: [],
+    users: [],
+    communityUsers: [],
+  });
+
+  if (permanent) {
+    scheduleTask(() => pushToTombstone('comment', commentId));
+  } else {
+    upsertInCache(['comment', 'get', commentId], { isDeleted: true });
+  }
+
+  return deleted;
+};

package/src/commentRepository/internalApi/flagComment.ts

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

package/src/commentRepository/internalApi/getComment.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+export const getComment = async (
+  commentId: Amity.InternalComment['commentId'],
+): Promise<Amity.Cached<Amity.InternalComment>> => {
+  const client = getActiveClient();
+  client.log('comment/getComment', commentId);
+
+  isInTombstone('comment', commentId);
+
+  let data: Amity.CommentPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.CommentPayload>(
+      `/api/v3/comments/${encodeURIComponent(commentId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('comment', commentId);
+    }
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { comments } = data;
+  return {
+    data: comments.find(comment => comment.commentId === commentId)!,
+    cachedAt,
+  };
+};
+
+getComment.locally = (
+  commentId: Amity.InternalComment['commentId'],
+): Amity.Cached<Amity.InternalComment> | undefined => {
+  const client = getActiveClient();
+  client.log('comment/getComment.locally', commentId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.InternalComment>(['comment', 'get', commentId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/commentRepository/internalApi/getCommentByIds.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+export const getCommentByIds = async (
+  commentIds: Amity.InternalComment['commentId'][],
+): Promise<Amity.Cached<Amity.InternalComment[]>> => {
+  const client = getActiveClient();
+  client.log('comment/getCommentByIds', commentIds);
+
+  const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
+
+  let data: Amity.CommentPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.CommentPayload>(`/api/v3/comments/list`, {
+      params: { commentIds: encodedCommentIds },
+    });
+
+    data = response.data;
+  } catch (error) {
+    commentIds.forEach(commentId => {
+      if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+        pushToTombstone('comment', commentId);
+      }
+    });
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.comments,
+    cachedAt,
+  };
+};
+
+getCommentByIds.locally = (
+  commentIds: Amity.InternalComment['commentId'][],
+): Amity.Cached<Amity.InternalComment[]> | undefined => {
+  const client = getActiveClient();
+  client.log('comment/getCommentByIds.locally', commentIds);
+
+  if (!client.cache) return;
+
+  const cached = commentIds
+    .map(commentId => pullFromCache<Amity.InternalComment>(['comment', 'get', commentId])!)
+    .filter(Boolean);
+
+  const comments = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < commentIds.length) return;
+
+  return {
+    data: comments,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/commentRepository/internalApi/hardDeleteComment.ts

@@ -0,0 +1,14 @@
+import { getActiveClient } from '~/client/api';
+
+import { deleteComment } from './deleteComment';
+
+export const hardDeleteComment = async (
+  commentId: Amity.InternalComment['commentId'],
+): Promise<Amity.InternalComment> => {
+  const client = getActiveClient();
+  client.log('comment/hardDeleteComment', commentId);
+
+  const hardDeleted = deleteComment(commentId, true);
+
+  return hardDeleted;
+};

package/src/commentRepository/internalApi/index.ts

@@ -0,0 +1,12 @@
+export * from './getCommentByIds';
+
+export * from './createComment';
+export * from './updateComment';
+
+export * from './deleteComment';
+export * from './softDeleteComment';
+export * from './hardDeleteComment';
+
+export * from './flagComment';
+export * from './unflagComment';
+export * from './isCommentFlaggedByMe';

package/src/commentRepository/internalApi/isCommentFlaggedByMe.ts

@@ -0,0 +1,14 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+export const isCommentFlaggedByMe = async (
+  commentId: Amity.InternalComment['commentId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('comment/isCommentFlaggedByMe', commentId);
+
+  const {
+    data: { result },
+  } = await client.http.get(`/api/v3/comments/${commentId}/isflagbyme`);
+
+  return result;
+};

package/src/commentRepository/internalApi/queryComments.ts

@@ -0,0 +1,54 @@
+import { getActiveClient } from '~/client/api';
+import { pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+import { convertToInternalComment } from '../utils/convertToInternalComment';
+
+export const queryComments = async (
+  query: Amity.QueryComments,
+): Promise<Amity.Cached<Amity.PageToken<Amity.InternalComment>>> => {
+  const client = getActiveClient();
+  client.log('comment/queryComments', query);
+
+  const { limit = 10, includeDeleted, ...params } = query;
+
+  const options = {
+    type: params.sortBy || query.limit ? 'pagination' : undefined,
+    limit: query.limit,
+    token: query.page,
+  };
+  // 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,
+        isDeleted: inferIsDeleted(includeDeleted),
+        //      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, ...payload } = data;
+  const processedData = convertToInternalComment(payload);
+  const { comments } = processedData;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(processedData as Amity.CommentPayload, { cachedAt });
+
+    const cacheKey = ['comment', 'query', { ...params, options: { limit } } as Amity.Serializable];
+    pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging });
+  }
+
+  return { data: comments, cachedAt, paging };
+};

package/src/commentRepository/internalApi/softDeleteComment.ts

@@ -0,0 +1,14 @@
+import { getActiveClient } from '~/client/api';
+
+import { deleteComment } from './deleteComment';
+
+export const softDeleteComment = async (
+  commentId: Amity.InternalComment['commentId'],
+): Promise<Amity.InternalComment> => {
+  const client = getActiveClient();
+  client.log('comment/softDeleteComment', commentId);
+
+  const softDeleted = deleteComment(commentId);
+
+  return softDeleted;
+};

package/src/commentRepository/internalApi/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('~/postRepository/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/commentRepository/internalApi/tests/deleteComment.test.ts

@@ -0,0 +1,60 @@
+import {
+  client,
+  comment11,
+  connectClient,
+  disconnectClient,
+  emptyPostPayload,
+  generateComment,
+  generatePost,
+  textCommentResponse,
+  user11,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { deleteComment } from '../deleteComment';
+
+const commentId = 'comment11';
+const commentData = generateComment({ commentId });
+
+const singlePostResponse = {
+  data: {
+    ...emptyPostPayload,
+    posts: [generatePost({ comments: [commentId], commentsCount: 1 })],
+    comments: [commentData],
+    users: [user11],
+  } as Amity.ProcessedPostPayload,
+};
+
+describe('deleteComment', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: ff01df65-2cc0-4fd8-8c3e-a12cea5a359b
+  test('should return success for soft and hard delete', async () => {
+    client.http.get = jest.fn().mockImplementation(url => {
+      if (url === '/api/v3/comments/comment11') return textCommentResponse;
+      // /api/v3/posts/postId11
+      return singlePostResponse;
+    });
+    client.http.delete = jest.fn().mockResolvedValueOnce({ success: true });
+
+    const result = await deleteComment(commentId);
+    expect(result.isDeleted).toEqual(true);
+    expect(result.commentId).toEqual(commentId);
+  });
+
+  // integration_test_id: 322954d6-bc89-40ae-bd18-691ee0c60105
+  test('should return error for deletion not successful', async () => {
+    client.http.get = jest.fn().mockImplementation(url => {
+      if (url === '/api/v3/comments/comment11') return textCommentResponse;
+      // /api/v3/posts/postId11
+      return singlePostResponse;
+    });
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(deleteComment(commentId)).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,48 @@
+import { enableCache, pushToCache } from '~/cache/api';
+import { client, comment11, connectClient, disconnectClient, user11 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { getCommentByIds } from '../getCommentByIds';
+
+const apiResponse = {
+  data: {
+    comments: [comment11],
+    commentChildren: [],
+    users: [user11],
+    files: [],
+  },
+};
+
+const commentsListResponse = {
+  data: [comment11],
+};
+
+describe('getCommentByIds', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the comments from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(apiResponse);
+    const { data } = await getCommentByIds([comment11.commentId]);
+    expect(data).toEqual(commentsListResponse.data);
+  });
+
+  test('Should return comments from locally', () => {
+    pushToCache(['user', 'get', user11.userId], user11);
+    const comments: ReturnType<typeof getCommentByIds.locally> = getCommentByIds.locally([
+      comment11.commentId,
+    ]);
+
+    expect(comments?.data).toEqual(commentsListResponse.data);
+  });
+
+  test('Should return Error: 400400 when getCommentByIds from invalid commentId', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getCommentByIds([comment11.commentId])).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,48 @@
+import { enableCache, pushToCache } from '~/cache/api';
+import { client, comment11, connectClient, disconnectClient, user11 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { getCommentByIds } from '../getCommentByIds';
+
+const apiResponse = {
+  data: {
+    comments: [comment11],
+    commentChildren: [],
+    users: [user11],
+    files: [],
+  },
+};
+
+const commentsListResponse = {
+  data: [comment11],
+};
+
+describe('getCommentByIds', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the comments from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(apiResponse);
+    const { data } = await getCommentByIds([comment11.commentId]);
+    expect(data).toEqual(commentsListResponse.data);
+  });
+
+  test('Should return comments from locally', () => {
+    pushToCache(['user', 'get', user11.userId], user11);
+    const comments: ReturnType<typeof getCommentByIds.locally> = getCommentByIds.locally([
+      comment11.commentId,
+    ]);
+
+    expect(comments?.data).toEqual(commentsListResponse.data);
+  });
+
+  test('Should return Error: 400400 when getCommentByIds from invalid commentId', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getCommentByIds([comment11.commentId])).rejects.toThrow();
+  });
+});