@amityco/ts-sdk-react-native 6.7.1-80c1951.0

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

@@ -0,0 +1,118 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
+
+import { convertQueryParams } from '../../utils';
+import { queryMessages } from '../queryMessages';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+const rawMessagesToQuery = [
+  generateRawMessage(),
+  generateRawMessage({ messageId: 'message-id-2' }),
+];
+
+const messagesToQuery = rawMessagesToQuery.map(convertRawMessage);
+const messageIds = messagesToQuery.map(x => x.messageId);
+const queryCriteriaWithoutPage = { subChannelId: messagesToQuery[0].subChannelId };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: { limit: 10 } };
+const paging = {
+  next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+};
+const nextPage = { before: 63471614391111000000, limit: 2 };
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: rawMessagesToQuery,
+    files: [],
+    users: [],
+    paging,
+  },
+});
+
+describe('queryMessages', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  test('should return fetched messages with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(queryMessages(queryCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: messagesToQuery,
+        nextPage,
+        prevPage: undefined,
+      }),
+    );
+  });
+
+  test('should update cache after fetching messages', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages(queryCriteria);
+
+    const recieved = pullFromCache(['message', 'query', convertQueryParams(queryCriteria)])?.data;
+
+    expect(recieved).toEqual({
+      messages: messageIds,
+      paging,
+    });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryMessages(queryCriteria)).rejects.toThrow('error');
+  });
+
+  test('should fire event `onMessageFetched`', async () => {
+    let dispose;
+
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageFetched(resolve);
+    }).finally(dispose);
+
+    await queryMessages(queryCriteria);
+    await expect(callbackPromise).resolves.toEqual(messagesToQuery[0]);
+  });
+
+  test('it should set isDeleted to undefined if includeDeleted is true', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages({ ...queryCriteriaWithoutPage, includeDeleted: true });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
+
+  test('it should set isDeleted to false if includeDeleted is false', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages({ ...queryCriteriaWithoutPage, includeDeleted: false });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+
+  test('it should set isDeleted to false if includeDeleted is undefined', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages(queryCriteriaWithoutPage);
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+});

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-react-native'
+ * 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

@@ -0,0 +1,104 @@
+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 { updateMessage } from '@amityco/ts-sdk-react-native'
+ * const updated = await updateMessage(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 updateMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  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),
+  );
+
+  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 { updateMessage } from '@amityco/ts-sdk-react-native'
+ * const updated = updateMessage.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
+ */
+updateMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/updateMessage.optimistically', patch);
+
+  if (!client.cache) return;
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const updated: Amity.Message = {
+    ...message.data,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], updated, { cachedAt });
+  fireEvent('local.message.updated', { messages: [updated] });
+
+  return {
+    data: updated,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/messageRepository/events/index.ts

@@ -0,0 +1,12 @@
+export * from './onMessageCreated';
+export * from './onMessageUpdated';
+export * from './onMessageDeleted';
+
+export * from './onMessageFlagged';
+export * from './onMessageUnflagged';
+export * from './onMessageFlagCleared';
+
+export * from './onMessageReactionAdded';
+export * from './onMessageReactionRemoved';
+
+export * from './onMessageFetched';

package/src/messageRepository/events/onMessageCreated.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { upsertInCache } from '~/cache/api';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageCreated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onMessageCreated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @param local Trigger when an event occurs from a local event or not
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageCreated = (
+  callback: Amity.Listener<Amity.Message>,
+  local = true,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
+    const message = payload.messages[0];
+
+    // Update in cache
+    ingestInCache(payload);
+
+    // Update lastActivity for Channel and SubChannel
+    payload.messages.forEach(({ channelId, subChannelId, createdAt }) => {
+      upsertInCache(['channel', 'get', channelId], { lastActivity: createdAt });
+      upsertInCache(['subChannel', 'get', channelId], { lastActivity: createdAt });
+    });
+
+    callback(message);
+  };
+
+  const disposers = [
+    createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
+  ];
+
+  if (local) {
+    createEventSubscriber(client, 'message/onMessageCreated', 'local.message.created', payload =>
+      callback(payload.messages[0]),
+    );
+  }
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/messageRepository/events/onMessageDeleted.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onMessageDeleted(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} was deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  const disposers = [
+    createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
+    createEventSubscriber(client, 'message/onMessageDeleted', 'local.message.deleted', payload =>
+      callback(payload.messages[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/messageRepository/events/onMessageFetched.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onMessageFetched } from '@amityco/ts-sdk-react-native'
+ * const dispose = onMessageFetched(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageFetched = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.message.fetched']) => {
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'message/onMessageFetched', 'local.message.fetched', filter);
+};

package/src/messageRepository/events/onMessageFlagCleared.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageFlagCleared } from '@amityco/ts-sdk-react-native'
+ * const dispose = onMessageFlagCleared(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageFlagCleared = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageFlagCleared', 'message.flagCleared', filter);
+};

package/src/messageRepository/events/onMessageFlagged.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageFlagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onMessageFlagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageFlagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageFlagged', 'message.flagged', filter);
+};

package/src/messageRepository/events/onMessageReactionAdded.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageReactionAdded } from '@amityco/ts-sdk-react-native';
+ *
+ * const unsubscribe = onMessageReactionAdded(message => {
+ *   // ...
+ * });
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onMessageReactionAdded = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload, 'message.reactionAdded');
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageReactionAdded', 'message.reactionAdded', filter);
+};

package/src/messageRepository/events/onMessageReactionRemoved.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageReactionRemoved } from '@amityco/ts-sdk-react-native';
+ *
+ * const unsubscribe = onMessageReactionRemoved(message => {
+ *   // ...
+ * });
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onMessageReactionRemoved = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload, 'message.reactionRemoved');
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'onMessageReactionRemoved',
+    'message.reactionRemoved',
+    filter,
+  );
+};

package/src/messageRepository/events/onMessageUnflagged.ts

@@ -0,0 +1,32 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageUnflagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onMessageUnflagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Message}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageUnflagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageUnflagged', 'message.unflagged', filter);
+};