@amityco/ts-sdk 6.2.0 → 6.2.1-0cf9bee.0

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/events/onMessageDeleted.ts

@@ -31,7 +31,7 @@ export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity
 
   const disposers = [
     createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
-    createEventSubscriber(client, 'local.message.deleted', 'local.message.deleted', payload =>
+    createEventSubscriber(client, 'message/onMessageDeleted', 'local.message.deleted', payload =>
       callback(payload.messages[0]),
     ),
   ];

package/src/messageRepository/observers/getMessages.ts

@@ -100,21 +100,20 @@ export const getMessages = (
     collection.data = [...new Set([message.messageId, ...collection.data])];
 
     pushToCache(cacheKey, collection);
-    disposers.push(() => dropFromCache(cacheKey));
 
     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(
@@ -151,7 +150,8 @@ export const getMessages = (
     onMessageReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`getMessages(tmpid: ${timestamp}) > dispose`);

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

@@ -135,21 +135,20 @@ export const getPosts = (
     }
 
     pushToCache(cacheKey, collection);
-    disposers.push(() => dropFromCache(cacheKey));
 
     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 +186,8 @@ export const getPosts = (
     onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
-  onFetch();
+  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`getPosts(tmpid: ${timestamp}) > dispose`);

package/src/reactionRepository/observers/getReactions.ts

@@ -91,16 +91,16 @@ export const getReactions = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
 
     const reactions = collection?.data ?? [];
 
-    if (reactions.length > 0 && !collection?.params?.page) return;
+    if (!initial && reactions.length > 0 && !collection?.params?.page) return;
 
     const query = createQuery(queryReactions, {
       ...queryParams,
-      page: collection?.params?.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -136,7 +136,7 @@ export const getReactions = (
     ),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`liveReactions(tmpid: ${timestamp}) > dispose`);

package/src/report/api/createReport.ts

@@ -8,7 +8,7 @@ import { prepareMessagePayload } from '~/messageRepository/utils';
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /* begin_public_function
-  id: user.flag, message.flag, post.flag, comment.flag
+  id: message.flag, post.flag, comment.flag
 */
 /**
  * ```js

package/src/report/api/tests/createReport.test.ts

@@ -1,14 +1,5 @@
-import { disableCache, enableCache, pullFromCache } from '~/cache/api';
-import {
-  client,
-  connectClient,
-  disconnectClient,
-  flaggedUser,
-  flaggedUserQueryResponse,
-} from '~/utils/tests';
-import { ASCApiError } from '~/core/errors';
-
-import { onUserFlagged } from '~/userRepository/events';
+import { disableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient } from '~/utils/tests';
 
 import { createReport } from '..';
 import REFERENCE_TYPES from '../../constants/referenceTypes';
@@ -18,48 +9,10 @@ describe('createReport', () => {
   beforeAll(connectClient);
   afterAll(disconnectClient);
 
-  // integration_test_id: ca4a760f-4342-4a99-9f3c-6c17cd205ca6
-  test('it should flag user with userId', async () => {
-    const expected = true;
-    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
-
-    const received = await createReport('user', flaggedUser.userId);
-
-    expect(received).toBe(expected);
-  });
-
-  // integration_test_id: e8d0f02c-3558-488f-bdae-e70835d8cefb
-  test('it should throw error with 400400 when sending invalid userId', async () => {
-    client.http.post = jest
-      .fn()
-      .mockRejectedValueOnce(
-        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
-      );
-
-    await expect(createReport('user', flaggedUser.userId)).rejects.toThrow('400400');
-  });
-
-  test('it should fire event for user', async () => {
-    let dispose;
-    const expected = flaggedUser;
-
-    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
-
-    const callbackPromise = new Promise(resolve => {
-      dispose = onUserFlagged(resolve);
-    }).finally(dispose);
-
-    const recieved = await createReport('user', flaggedUser.userId);
-
-    expect(recieved).toBe(true);
-    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
-  });
-
   test.todo('it should fire event for flagging message');
   test.todo('it should fire event for flagging post');
 
   const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
-    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
     ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/flag`],
     ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
   ];
@@ -78,17 +31,4 @@ describe('createReport', () => {
       expect(received).toBe(expected);
     },
   );
-
-  test('it should add data to cache', async () => {
-    enableCache();
-    const expected = flaggedUser;
-    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
-
-    await createReport('user', flaggedUser.userId);
-    const recieved = pullFromCache(['user', 'get', flaggedUser.userId]);
-
-    expect(recieved?.data).toBe(expected);
-
-    disableCache();
-  });
 });