@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,138 +0,0 @@
-import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { isInTombstone } from '~/cache/api/isInTombstone';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { ASCApiError } from '~/core/errors';
-import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
-
-import { getMessage } from '../getMessage';
-import { onMessageFetched } from '../../events/onMessageFetched';
-import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
-
-const rawMessageToGet = generateRawMessage();
-const messageToGet = convertRawMessage(rawMessageToGet);
-const { messageId } = messageToGet;
-
-const getResolvedMessageValue = () => ({
-  data: {
-    messages: [rawMessageToGet],
-    users: [],
-    files: [],
-  },
-});
-
-describe('getMessage', () => {
-  beforeAll(() => {
-    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
-      Promise.resolve({
-        data: [],
-        cachedAt: undefined,
-      }),
-    );
-  });
-
-  // integration_test_id: bc048747-17ea-43fe-9f97-7b2bf008c476
-  test('should return fetched message', async () => {
-    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
-
-    await expect(getMessage(messageId)).resolves.toEqual(
-      expect.objectContaining({ data: messageToGet }),
-    );
-  });
-
-  test('should update cache after fetching message', async () => {
-    enableCache();
-    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
-
-    await getMessage(messageId);
-    const recieved = pullFromCache(['message', 'get', messageId])?.data;
-
-    expect(recieved).toEqual(messageToGet);
-
-    disableCache();
-  });
-
-  // integration_test_id: 81375153-2886-46e0-a164-7f3902e77b55
-  test('should return 400300 if unauthorized', async () => {
-    client.http.get = jest
-      .fn()
-      .mockRejectedValueOnce(
-        new ASCApiError('forbidden', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.ERROR),
-      );
-
-    await expect(getMessage(messageId)).rejects.toThrow('400300');
-  });
-
-  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 getMessage(messageId);
-
-    await expect(callbackPromise).resolves.toEqual(messageToGet);
-  });
-});
-
-describe('getMessage tombostone', () => {
-  beforeEach(() => enableCache());
-  afterEach(() => disableCache());
-
-  test('should add message to tombostone if 404', async () => {
-    expect.assertions(2);
-
-    client.http.get = jest
-      .fn()
-      .mockRejectedValueOnce(
-        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
-      );
-
-    await expect(getMessage(messageId)).rejects.toThrow();
-
-    expect(() => isInTombstone('message', messageId)).toThrow();
-  });
-
-  test('should throw error if message not found in tombostone', async () => {
-    pushToTombstone('message', messageId);
-
-    await expect(getMessage(messageId)).rejects.toThrow();
-  });
-});
-
-describe('getMessage.locally', () => {
-  beforeEach(() => enableCache());
-  afterEach(() => disableCache());
-
-  test('should return cached message', () => {
-    pushToCache(['message', 'get', messageId], messageToGet);
-
-    expect(getMessage.locally(messageId)?.data).toBe(messageToGet);
-  });
-
-  test('it should return undefined if message not in cache', () => {
-    expect(getMessage.locally('non-existent-message')).toBeUndefined();
-  });
-
-  test('should return undefined if cache not enabled', () => {
-    disableCache();
-    pushToCache(['message', 'get', messageId], messageToGet);
-
-    expect(getMessage.locally(messageId)).toBeUndefined();
-  });
-
-  test('should return undefined if 404', async () => {
-    expect.assertions(2);
-    pushToCache(['message', 'get', messageId], messageToGet);
-
-    client.http.get = jest
-      .fn()
-      .mockRejectedValueOnce(
-        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
-      );
-
-    await expect(getMessage(messageId)).rejects.toThrow();
-    expect(getMessage.locally(messageId)).toBeUndefined();
-  });
-});

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

@@ -1,116 +0,0 @@
-import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { ASCApiError } from '~/core/errors';
-import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
-
-import { getMessages } from '../getMessages';
-import { onMessageFetched } from '../../events/onMessageFetched';
-import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
-
-const rawMessagesToGet = [generateRawMessage(), generateRawMessage({ messageId: 'message-id-2' })];
-const messagesToGet = rawMessagesToGet.map(convertRawMessage);
-const messageIds = messagesToGet.map(x => x.messageId);
-
-const getResolvedMessageValue = () => ({
-  data: {
-    messages: rawMessagesToGet,
-    users: [],
-    files: [],
-  },
-});
-
-describe('getMessages', () => {
-  beforeAll(() => {
-    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
-      Promise.resolve({
-        data: [],
-        cachedAt: undefined,
-      }),
-    );
-  });
-
-  test('should return fetched messages', async () => {
-    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
-
-    await expect(getMessages(messageIds)).resolves.toEqual(
-      expect.objectContaining({ data: messagesToGet }),
-    );
-  });
-
-  test('should update cache after fetching messages', async () => {
-    enableCache();
-    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
-
-    await getMessages(messageIds);
-
-    const recieved = messageIds.map(
-      messageId => pullFromCache(['message', 'get', messageId])?.data,
-    );
-
-    expect(recieved).toEqual(messagesToGet);
-
-    disableCache();
-  });
-
-  test('should throw an error if request fails', async () => {
-    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
-
-    await expect(getMessages(messageIds)).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 getMessages(messageIds);
-    await expect(callbackPromise).resolves.toEqual(messagesToGet[0]);
-  });
-});
-
-describe('getMessages tombostone', () => {
-  test.todo('should add messages to tombostone if 404');
-  test.todo('should throw error if messages not found in tombostone');
-});
-
-describe('getMessages.locally', () => {
-  beforeEach(enableCache);
-  afterEach(enableCache);
-
-  test('should return cached messages', () => {
-    messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));
-
-    expect(getMessages.locally(messageIds)?.data).toEqual(messagesToGet);
-  });
-
-  test('it should return undefined if message not in cache', () => {
-    expect(getMessages.locally(['non-existent-message'])).toBeUndefined();
-  });
-
-  test('should return undefined if cache not enabled', () => {
-    disableCache();
-    messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));
-
-    expect(getMessages.locally(messageIds)).toBeUndefined();
-  });
-
-  /* TODO: re-enable this once tombstone has been implemented */
-  test.skip('should return undefined if 404', async () => {
-    expect.assertions(2);
-
-    const error = new ASCApiError(
-      'not found!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    client.http.get = jest.fn().mockRejectedValueOnce(error);
-    messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));
-
-    await expect(getMessages(messageIds)).rejects.toThrow();
-
-    expect(getMessages.locally(messageIds)).toBeUndefined();
-  });
-});

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

@@ -1,90 +0,0 @@
-import { pullFromCache, enableCache, disableCache } from '~/cache/api';
-import { getResolver } from '~/core/model';
-
-import {
-  client,
-  connectClient,
-  disconnectClient,
-  generateFeedMarker,
-  generateUserMarkerResponse,
-  generateChannelMarker,
-  generateSubChannelMarker,
-  activeUser,
-  generateUserMarker,
-  generateChannelMarkerResponse,
-  generateSubChannelMarkerResponse,
-} from '~/utils/tests';
-
-import { markAsDelivered } from '../markAsDelivered';
-
-const { userId } = activeUser;
-const entityId = 'feed1';
-const feedId = 'sub-ch1';
-const messageId = 'message1';
-
-const userMarkersResponse = generateUserMarkerResponse({ userId });
-const channelMarkersResponse = generateChannelMarkerResponse({ userId, entityId });
-const subChannelMarkerResponse = generateSubChannelMarkerResponse({ userId, feedId, entityId });
-
-const expectedUserMarker = generateUserMarker({ userId });
-const expectedChannelMarker = generateChannelMarker({ userId, entityId });
-const expectedSubChannelMarker = generateSubChannelMarker({ userId, feedId, entityId });
-const expectedFeedMarker = generateFeedMarker({ feedId, entityId });
-
-const resolvedPutValue = {
-  data: {
-    userMarkers: [userMarkersResponse],
-    userEntityMarkers: [channelMarkersResponse],
-    userFeedMarkers: [subChannelMarkerResponse],
-    feedMarkers: [expectedFeedMarker],
-  } as Amity.MarkDeliveredPayload,
-};
-
-describe('markAsDelivered', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  test('it should return `true`', async () => {
-    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
-
-    const recieved = await markAsDelivered(feedId, messageId);
-
-    expect(recieved).toBe(true);
-  });
-
-  test('it should update cache', async () => {
-    expect.assertions(4);
-    enableCache();
-
-    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
-
-    await markAsDelivered(feedId, messageId);
-
-    const recievedUserMarkerCache = pullFromCache(['userMarker', 'get', userId]);
-
-    const recievedChannelMarkerCache = pullFromCache([
-      'channelMarker',
-      'get',
-      getResolver('channelMarker')({ entityId, userId }),
-    ]);
-
-    const recievedSubChannelMarkerCache = pullFromCache([
-      'subChannelMarker',
-      'get',
-      getResolver('subChannelMarker')({ entityId, feedId, userId }),
-    ]);
-
-    const recievedFeedMarkerCache = pullFromCache([
-      'feedMarker',
-      'get',
-      getResolver('feedMarker')({ entityId, feedId }),
-    ]);
-
-    expect(recievedUserMarkerCache?.data).toStrictEqual(expectedUserMarker);
-    expect(recievedChannelMarkerCache?.data).toStrictEqual(expectedChannelMarker);
-    expect(recievedSubChannelMarkerCache?.data).toStrictEqual(expectedSubChannelMarker);
-    expect(recievedFeedMarkerCache?.data).toStrictEqual(expectedFeedMarker);
-
-    disableCache();
-  });
-});

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

@@ -1,118 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: message.edit
-*/
-/**
- * ```js
- * import { updateMessage } from '@amityco/ts-sdk'
- * 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: LinkedObject.message(messages.find(message => message.messageId === messageId)!),
-    cachedAt,
-  };
-};
-
-/**
- * ```js
- * import { updateMessage } from '@amityco/ts-sdk'
- * 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.InternalMessage>(['message', 'get', messageId]);
-
-  if (!message) return;
-
-  const cachedAt = -1;
-  const updated: Amity.InternalMessage = {
-    ...message.data,
-    ...patch,
-    updatedAt: new Date().toISOString(),
-  };
-
-  upsertInCache(['message', 'get', messageId], updated, { cachedAt });
-  fireEvent('local.message.updated', { messages: [updated] });
-
-  return {
-    data: LinkedObject.message(updated),
-    cachedAt,
-  };
-};
-/* end_public_function */