@amityco/ts-sdk 6.2.1-b60a2f4.0 → 6.2.1-b68e715.0

package/src/messageRepository/api/tests/{updateMessage.test.ts → editMessage.test.ts}

@@ -2,7 +2,7 @@ import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { client, generateRawMessage } from '~/utils/tests';
 
-import { updateMessage } from '../updateMessage';
+import { editMessage } from '../editMessage';
 import { onMessageUpdated } from '../../events';
 import { convertFromRaw } from '../../utils';
 
@@ -21,12 +21,12 @@ const getResolvedMessageValue = () => ({
   },
 });
 
-describe('updateMessage', () => {
+describe('editMessage', () => {
   // integration_test_id: 3ae17ea2-dee5-4418-88af-fe809ee48a52
   test('should return updated message', async () => {
     client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    const recieved = updateMessage(messageId, patch);
+    const recieved = editMessage(messageId, patch);
 
     await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedMessage }));
   });
@@ -39,14 +39,14 @@ describe('updateMessage', () => {
         new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
       );
 
-    await expect(updateMessage(messageId, patch)).rejects.toThrow('400400');
+    await expect(editMessage(messageId, patch)).rejects.toThrow('400400');
   });
 
   test('should update cache after updated messages', async () => {
     enableCache();
     client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    await updateMessage(messageId, patch);
+    await editMessage(messageId, patch);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', messageId])?.data;
 
     expect(recieved).toEqual(expect.objectContaining(patch));
@@ -62,20 +62,20 @@ describe('updateMessage', () => {
       dispose = onMessageUpdated(resolve);
     }).finally(dispose);
 
-    await updateMessage(messageId, patch);
+    await editMessage(messageId, patch);
 
     await expect(callbackPromise).resolves.toEqual(expect.objectContaining(updatedMessage));
   });
 });
 
-describe('updateMessage.optimistically', () => {
+describe('editMessage.optimistically', () => {
   beforeEach(() => enableCache());
   afterEach(() => disableCache());
 
   test('should update cache after updated message', () => {
     pushToCache(['message', 'get', messageId], messageToUpdate);
 
-    updateMessage.optimistically(messageId, patch);
+    editMessage.optimistically(messageId, patch);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', messageId])?.data;
 
     expect(recieved).toEqual(expect.objectContaining(patch));
@@ -90,7 +90,7 @@ describe('updateMessage.optimistically', () => {
       });
     }).finally(dispose);
 
-    updateMessage.optimistically(messageId, patch);
+    editMessage.optimistically(messageId, patch);
 
     await expect(callbackPromise).resolves.toEqual(
       expect.objectContaining({
@@ -103,6 +103,6 @@ describe('updateMessage.optimistically', () => {
   test('should define object as unsynced object', () => {
     pushToCache(['message', 'get', messageId], messageToUpdate);
 
-    expect(updateMessage.optimistically(messageId, patch)?.cachedAt).toBe(-1);
+    expect(editMessage.optimistically(messageId, patch)?.cachedAt).toBe(-1);
   });
 });

package/src/messageRepository/api/tests/flagMessage.test.ts

@@ -0,0 +1,87 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, generateRawMessage, user11 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { fireEvent } from '~/core/events';
+
+import { flagMessage } from '..';
+import { convertFromRaw } from '../../utils';
+
+jest.mock('~/core/events', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/events'),
+  fireEvent: jest.fn(),
+}));
+
+const flaggedRawMessage = generateRawMessage({ flagCount: 1 });
+const message = convertFromRaw(flaggedRawMessage);
+const { messageId } = flaggedRawMessage;
+
+const flaggedMessageQueryResponse = {
+  data: {
+    messages: [flaggedRawMessage],
+    users: [user11],
+  },
+};
+
+describe('flagMessage', () => {
+  beforeEach(disableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: fd507b43-99e7-4aed-816d-d51d357d303b
+  test('it should flag message with messageId', async () => {
+    const expected = true;
+    client.http.post = jest.fn().mockResolvedValue(flaggedMessageQueryResponse);
+
+    const received = await flagMessage(messageId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: 0c78c9fd-1d4e-4af7-ad6b-e76372addb2f
+  test('it should throw error with 400400 when sending invalid messageId', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(flagMessage(messageId)).rejects.toThrow('400400');
+  });
+
+  test('it should call fire event method', async () => {
+    client.http.post = jest.fn().mockResolvedValue(flaggedMessageQueryResponse);
+
+    const recieved = await flagMessage(messageId);
+    const [recievedMqttString] = (fireEvent as jest.Mock).mock.lastCall;
+
+    expect(recieved).toBe(true);
+    expect(recievedMqttString).toBe('message.flagged');
+  });
+
+  test('it should call the appropriate api', async () => {
+    const apimock = jest.fn();
+    const expected = `/api/v5/messages/${encodeURIComponent('messageId')}/flags`;
+
+    client.http.post = apimock.mockResolvedValue({ data: {} });
+
+    await flagMessage('messageId');
+
+    const received = apimock.mock.lastCall[0];
+
+    expect(received).toBe(expected);
+  });
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = message;
+    client.http.post = jest.fn().mockResolvedValue(flaggedMessageQueryResponse);
+
+    await flagMessage(messageId);
+    const recieved = pullFromCache(['message', 'get', messageId]);
+
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+});

package/src/messageRepository/api/tests/unflagMessage.test.ts

@@ -0,0 +1,87 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, generateRawMessage, user11 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { fireEvent } from '~/core/events';
+
+import { unflagMessage } from '..';
+import { convertFromRaw } from '../../utils';
+
+jest.mock('~/core/events', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/events'),
+  fireEvent: jest.fn(),
+}));
+
+const unflaggedRawMessage = generateRawMessage();
+const message = convertFromRaw(unflaggedRawMessage);
+const { messageId } = unflaggedRawMessage;
+
+const unflaggedMessageQueryResponse = {
+  data: {
+    messages: [unflaggedRawMessage],
+    users: [user11],
+  },
+};
+
+describe('unflagMessage', () => {
+  beforeEach(disableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: afb432ec-52eb-49d7-8054-c162e3b60535
+  test('it should unflag message with messageId', async () => {
+    const expected = true;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedMessageQueryResponse);
+
+    const received = await unflagMessage(messageId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: 5c6b5a0a-628d-4834-8453-d11df656dea8
+  test('it should throw error with 400400 when sending invalid messageId', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(unflagMessage(messageId)).rejects.toThrow('400400');
+  });
+
+  test('it should call fire event method', async () => {
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedMessageQueryResponse);
+
+    const recieved = await unflagMessage(messageId);
+    const [recievedMqttString] = (fireEvent as jest.Mock).mock.lastCall;
+
+    expect(recieved).toBe(true);
+    expect(recievedMqttString).toBe('message.unflagged');
+  });
+
+  test('it should call the appropriate api', async () => {
+    const apimock = jest.fn();
+    const expected = `/api/v5/messages/${encodeURIComponent('messageId')}/flags`;
+
+    client.http.delete = apimock.mockResolvedValue({ data: {} });
+
+    await unflagMessage('messageId');
+
+    const received = apimock.mock.lastCall[0];
+
+    expect(received).toBe(expected);
+  });
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = message;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedMessageQueryResponse);
+
+    await unflagMessage(messageId);
+    const recieved = pullFromCache(['message', 'get', messageId]);
+
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+});

package/src/messageRepository/api/unflagMessage.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { fireEvent } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/* begin_public_function
+  id: message.unflag
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const unflagged = await MessageRepository.unflag(messageId)
+ * ```
+ *
+ * @param messageId of the message to unflag
+ * @returns boolean to indicate success
+ *
+ * @category Report API
+ * @async
+ * */
+export const unflagMessage = async (messageId: Amity.Message['messageId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/unflag', messageId);
+
+  const { data: payload } = await client.http.delete<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent('message.unflagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/messageRepository/api/updateMessage.ts

@@ -33,6 +33,10 @@ export const updateMessage = async (
   const client = getActiveClient();
   client.log('message/updateMessage', patch);
 
+  console.warn(
+    'MessageRepository.updateMessage will be replaced with MessageRepository.editMessage',
+  );
+
   const { data: payload } = await client.http.put<Amity.MessagePayload>(
     `/api/v5/messages/${encodeURIComponent(messageId)}`,
     convertParams(patch),

package/src/messageRepository/observers/getMessages.ts

@@ -104,16 +104,16 @@ export const getMessages = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
 
     const messages = collection?.data ?? [];
 
-    if (messages.length > 0 && !collection?.params?.page) return;
+    if (!initial && messages.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryMessages, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -150,7 +150,7 @@ export const getMessages = (
     onMessageReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
   disposers.push(() => dropFromCache(cacheKey));
 
   return () => {

package/src/postRepository/api/deletePost.ts

@@ -7,9 +7,6 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { getPost } from './getPost';
 
-/* begin_public_function
-  id: post.soft_delete, post.hard_delete
-*/
 /**
  * ```js
  * import { deletePost } from '@amityco/ts-sdk'
@@ -21,7 +18,7 @@ import { getPost } from './getPost';
  * @param postId The {@link Amity.Post} ID to delete
  * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Post API
+ * @private
  * @async
  */
 export const deletePost = async (
@@ -29,11 +26,9 @@ export const deletePost = async (
   permanent = false,
 ): Promise<Amity.Post> => {
   const client = getActiveClient();
-  client.log('post/deletePost', postId);
 
   const post = await getPost(postId);
 
-  // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(`/api/v4/posts/${encodeURIComponent(postId)}`, {
     params: {
       postId,
@@ -82,4 +77,3 @@ export const deletePost = async (
 
   return deleted;
 };
-/* end_public_function */

package/src/postRepository/api/editPost.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.edit
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const updated = await PostRepository.editPost(postId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Post}
+ *
+ * @param postId The ID of the {@link Amity.Post} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Post} object
+ *
+ * @category Post API
+ * @async
+ */
+export const editPost = async <T extends Amity.PostContentType>(
+  postId: Amity.Post['postId'],
+  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'> & {
+    attachments?: {
+      type: T;
+      fileId: Amity.File['fileId'];
+    }[];
+  },
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('user/editPost', patch);
+
+  const { data: payload } = await client.http.put<Amity.PostPayload>(
+    `/api/v4/posts/${encodeURIComponent(postId)}`,
+    patch,
+  );
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('post.updated', data);
+
+  const { posts } = data;
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/postRepository/api/flagPost.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.flag
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const flagged = await PostRepository.flagPost(postId)
+ * ```
+ *
+ * @param postId of the post to flag
+ * @returns a boolean
+ *
+ * @category Post API
+ * @async
+ * */
+export const flagPost = async (postId: Amity.Post['postId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('post/flagPost', postId);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/flag`,
+  );
+
+  if (client.cache) {
+    ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+  }
+
+  fireEvent('post.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/postRepository/api/hardDeletePost.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+
+import { deletePost } from './deletePost';
+
+/* begin_public_function
+  id: post.hard_delete
+*/
+/**
+ * ```js
+ * import { hardDeletePost } from '@amityco/ts-sdk'
+ * const success = await hardDeletePost('foobar')
+ * ```
+ *
+ * Hard deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be hard delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @category Post API
+ * @async
+ */
+export const hardDeletePost = async (postId: Amity.Post['postId']): Promise<Amity.Post> => {
+  const client = getActiveClient();
+  client.log('post/hardDeletePost', postId);
+
+  const hardDeleted = await deletePost(postId, true);
+
+  return hardDeleted;
+};
+/* end_public_function */

package/src/postRepository/api/index.ts

@@ -2,7 +2,15 @@ export * from './getPostByIds';
 
 export * from './createPost';
 export * from './updatePost';
+export * from './editPost';
+
 export * from './deletePost';
+export * from './softDeletePost';
+export * from './hardDeletePost';
 
 export * from './approvePost';
 export * from './declinePost';
+
+export * from './flagPost';
+export * from './unflagPost';
+export * from './isPostFlaggedByMe';

package/src/postRepository/api/isPostFlaggedByMe.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
+
+/* begin_public_function
+  id: post.check_flag_by_me
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
+ * ```
+ *
+ * @param postId of the post to check if flagged by current user
+ * @returns `true` if the post is flagged by me, `false` if doesn't.
+ *
+ * @category Post API
+ * @async
+ * */
+export const isPostFlaggedByMe = async (postId: Amity.Post['postId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('post/isPostFlaggedByMe', postId);
+
+  const { result, isFlagByMe } =
+    (await synchronousWSCall<{
+      result?: boolean;
+      isFlagByMe?: boolean;
+    }>(client, 'v3/post.isflagbyme', {
+      postId,
+    })) ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+/* end_public_function */

package/src/postRepository/api/softDeletePost.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+
+import { deletePost } from './deletePost';
+
+/* begin_public_function
+  id: post.soft_delete
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const success = await PostRepository.softDeletePost('foobar')
+ * ```
+ *
+ * Soft deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to soft delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @category Post API
+ * @async
+ */
+export const softDeletePost = async (postId: Amity.Post['postId']): Promise<Amity.Post> => {
+  const client = getActiveClient();
+  client.log('post/softDeletePost', postId);
+
+  const softDeleted = await deletePost(postId, false);
+
+  return softDeleted;
+};
+/* end_public_function */

package/src/postRepository/api/unflagPost.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.unflag
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const unflagged = await PostRepository.unflagPost(postId)
+ * ```
+ *
+ * @param postId of the post to unflag
+ * @returns the unflag post result
+ *
+ * @category Post API
+ * @async
+ * */
+export const unflagPost = async (postId: Amity.Post['postId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('post/unflagPost', postId);
+
+  const { data: payload } = await client.http.delete<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/unflag`,
+  );
+
+  if (client.cache) {
+    ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+  }
+
+  fireEvent('post.unflagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/postRepository/api/updatePost.ts

@@ -36,6 +36,10 @@ export const updatePost = async <T extends Amity.PostContentType>(
   const client = getActiveClient();
   client.log('user/updatePost', patch);
 
+  console.warn(
+    'Deprecation: updatePost has been renamed to editPost. Update post API will be deprecated soon.',
+  );
+
   const { data: payload } = await client.http.put<Amity.PostPayload>(
     `/api/v4/posts/${encodeURIComponent(postId)}`,
     patch,

package/src/postRepository/observers/getPosts.ts

@@ -140,16 +140,16 @@ export const getPosts = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
 
     const posts = collection?.data ?? [];
 
-    if (posts.length > 0 && !collection?.params?.page) return;
+    if (!initial && posts.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryPosts, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -187,7 +187,7 @@ export const getPosts = (
     onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`getPosts(tmpid: ${timestamp}) > dispose`);