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

package/src/fileRepository/api/{createImage.ts → uploadImage.ts}

@@ -7,8 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { createImage } from '@amityco/ts-sdk'
- * const created = await createImage(formData)
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadImage(formData)
  * ```
  *
  * Creates an {@link Amity.File<'image'>}
@@ -20,12 +20,12 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category File API
  * @async
  */
-export const createImage = async (
+export const uploadImage = async (
   formData: FormData,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'image'>[]>> => {
   const client = getActiveClient();
-  client.log('file/createImage', formData);
+  client.log('file/uploadImage', formData);
 
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
@@ -58,5 +58,3 @@ export const createImage = async (
   };
 };
 /* end_public_function */
-
-// TODO: consider doing local creation with URL.createObjectURL()

package/src/fileRepository/api/{createVideo.ts → uploadVideo.ts}

@@ -7,8 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 */
 /**
  * ```js
- * import { createVideo } from '@amityco/ts-sdk'
- * const created = await createVideo(formData)
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadVideo(formData)
  * ```
  *
  * Creates an {@link Amity.File<'video'>}
@@ -16,18 +16,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
  * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
- * @returns The newly created {@link Amity.File<'video'>}
+ * @returns The newly uploaded {@link Amity.File<'video'>}
  *
  * @category File API
  * @async
  */
-export const createVideo = async (
+export const uploadVideo = async (
   formData: FormData,
   feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
-  client.log('file/createVideo', formData);
+  client.log('file/uploadVideo', formData);
 
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
@@ -64,5 +64,3 @@ export const createVideo = async (
   };
 };
 /* end_public_function */
-
-// TODO: consider doing local creation with URL.createObjectURL()

package/src/marker/events/index.ts

@@ -4,6 +4,7 @@ export * from './onSubChannelMarkerFetched';
 export * from './onSubChannelMarkerUpdated';
 
 export * from './onFeedlMarkerFetched';
+export * from './onFeedlMarkerUpdated';
 
 export * from './onUserMarkerFetched';
 

package/src/marker/events/onFeedlMarkerUpdated.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerUpdated(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.FeedMarker} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+export const onFeedMarkerUpdated = (
+  callback: Amity.Listener<Amity.FeedMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['marker.feed-updated']) => {
+    callback(payload.feedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'feedMarker/onFeedMarkerUpdated',
+    'marker.feed-updated',
+    filter,
+  );
+};

package/src/messageRepository/api/editMessage.ts

@@ -0,0 +1,100 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+import { convertParams, prepareMessagePayload } from '../utils';
+
+/* begin_public_function
+  id: message.edit
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const updated = await MessageRepository.editMessage(messageId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message}
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const editMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/editMessage', patch);
+
+  const { data: payload } = await client.http.put<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    convertParams(patch),
+  );
+
+  const data = await prepareMessagePayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('local.message.updated', { messages });
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { editMessage } from '@amityco/ts-sdk'
+ * const updated = editMessage.optimistically('foobar', {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message} in cache
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+editMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/editMessage.optimistically', patch);
+
+  if (!client.cache) return;
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const edited: Amity.Message = {
+    ...message.data,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], edited, { cachedAt });
+  fireEvent('local.message.updated', { messages: [edited] });
+
+  return {
+    data: edited,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/messageRepository/api/flagMessage.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.flag
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const flagged = await MessageRepository.flagMessage(messageId)
+ * ```
+ *
+ * @param messageId of the message to flag
+ * @returns the created report result
+ *
+ * @category Message API
+ * @async
+ * */
+export const flagMessage = async (messageId: Amity.Message['messageId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/flag', messageId);
+
+  const { data: payload } = await client.http.post<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent('message.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/messageRepository/api/index.ts

@@ -2,7 +2,13 @@ export { getMessages as getMessageByIds } from './getMessages';
 
 export * from './createMessage';
 export * from './updateMessage';
-export * from './deleteMessage';
+export * from './editMessage';
+export * from './softDeleteMessage';
+
 export * from './markAsDelivered';
 export * from './getReadUsers';
 export * from './getDeliveredUsers';
+
+export * from './flagMessage';
+export * from './unflagMessage';
+export * from './isMessageFlaggedByMe';

package/src/messageRepository/api/isMessageFlaggedByMe.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/* begin_public_function
+  id: message.check_flag_by_me
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const isReportedByMe = await MessageRepository.isMessageFlaggedByMe(messageId)
+ * ```
+ *
+ * @param messageId of the message to check a report of.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ * */
+export const isMessageFlaggedByMe = async (
+  messageId: Amity.Message['messageId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/isMessageFlaggedByMe', messageId);
+
+  const { data } = await client.http.get<{ result: boolean }>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  return data.result;
+};
+/* end_public_function */

package/src/messageRepository/api/markAsDelivered.ts

@@ -3,8 +3,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
- * import { markAsDelivered } from '@amityco/ts-sdk'
- * const success = await markAsDelivered('subChannelId', 'messageId')
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const success = await MessageRepository.markAsDelivered('subChannelId', 'messageId')
  * ```
  *
  * Update `deliveredToSegment` in  {@link Amity.SubChannelMarker}

package/src/messageRepository/api/{deleteMessage.ts → softDeleteMessage.ts}

@@ -9,8 +9,8 @@ import { getMessage } from './getMessage';
 */
 /**
  * ```js
- * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = await deleteMessage('foobar')
+ * import { softDeleteMessage } from '@amityco/ts-sdk'
+ * const success = await softDeleteMessage('foobar')
  * ```
  *
  * Delete a {@link Amity.Message}
@@ -21,11 +21,11 @@ import { getMessage } from './getMessage';
  * @category Message API
  * @async
  */
-export const deleteMessage = async (
+export const softDeleteMessage = async (
   messageId: Amity.Message['messageId'],
 ): Promise<Amity.Message> => {
   const client = getActiveClient();
-  client.log('message/deleteMessage', messageId);
+  client.log('message/softDeleteMessage', messageId);
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
@@ -41,8 +41,8 @@ export const deleteMessage = async (
 
 /**
  * ```js
- * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = deleteMessage.optimistically('foobar')
+ * import { softDeleteMessage } from '@amityco/ts-sdk'
+ * const success = softDeleteMessage.optimistically('foobar')
  * ```
  *
  * Deletes a {@link Amity.Message}
@@ -52,11 +52,11 @@ export const deleteMessage = async (
  *
  * @category Message API
  */
-deleteMessage.optimistically = (
+softDeleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('message/deleteMessage.optimistically', messageId);
+  client.log('message/softDeleteMessage.optimistically', messageId);
 
   const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 

package/src/messageRepository/api/tests/deleteMessage.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 { deleteMessage } from '../deleteMessage';
+import { softDeleteMessage } from '../softDeleteMessage';
 import { onMessageDeleted } from '../../events';
 import { convertFromRaw } from '../../utils';
 
@@ -20,13 +20,13 @@ const getResolvedMessageValue = () => ({
   },
 });
 
-describe('deleteMessage', () => {
+describe('softDeleteMessage', () => {
   // integration_test_id: 16106137-0e4a-4d2f-b8cf-1a6c571bf0c7
   test('should return deleted message', async () => {
     client.http.delete = jest.fn();
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessage);
+    await expect(softDeleteMessage(deleteId)).resolves.toEqual(deletedMessage);
   });
 
   // integration_test_id: 27d393d9-480e-4eec-bfdb-f04738801b04
@@ -37,7 +37,7 @@ describe('deleteMessage', () => {
         new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
       );
 
-    await expect(deleteMessage(deleteId)).rejects.toThrow('400400');
+    await expect(softDeleteMessage(deleteId)).rejects.toThrow('400400');
   });
 
   test('should update cache after deleted messages', async () => {
@@ -46,7 +46,7 @@ describe('deleteMessage', () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
     pushToCache(['message', 'get', deleteId], messageToDelete);
 
-    await deleteMessage(deleteId);
+    await softDeleteMessage(deleteId);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
 
     expect(recieved).toEqual(deletedMessage);
@@ -63,20 +63,20 @@ describe('deleteMessage', () => {
       dispose = onMessageDeleted(resolve);
     }).finally(dispose);
 
-    await deleteMessage(deleteId);
+    await softDeleteMessage(deleteId);
 
     await expect(callbackPromise).resolves.toEqual(deletedMessage);
   });
 });
 
-describe('deleteMessage.optimistically', () => {
+describe('softDeleteMessage.optimistically', () => {
   beforeEach(() => enableCache());
   afterEach(() => disableCache());
 
   test('should update `isDeleted` in cache after deleted message', () => {
     pushToCache(['message', 'get', deleteId], messageToDelete);
 
-    deleteMessage.optimistically(deleteId);
+    softDeleteMessage.optimistically(deleteId);
     const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
 
     expect(recieved).toEqual({
@@ -91,7 +91,7 @@ describe('deleteMessage.optimistically', () => {
     pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
     pushToCache(['message', 'get', deleteId], { ...messageToDelete, channelId });
 
-    deleteMessage.optimistically(deleteId);
+    softDeleteMessage.optimistically(deleteId);
     const recieved = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
 
     expect(recieved?.messageCount).toBe(1);
@@ -107,7 +107,7 @@ describe('deleteMessage.optimistically', () => {
       });
     }).finally(dispose);
 
-    await deleteMessage.optimistically(deleteId);
+    softDeleteMessage.optimistically(deleteId);
 
     await expect(callbackPromise).resolves.toEqual({
       ...deletedMessage,
@@ -118,6 +118,6 @@ describe('deleteMessage.optimistically', () => {
   test('should define object as unsynced object', () => {
     pushToCache(['message', 'get', deleteId], messageToDelete);
 
-    expect(deleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
+    expect(softDeleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
   });
 });

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();
+  });
+});