@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/message/tests/observers/liveMessages.test.ts

@@ -0,0 +1,360 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  messages,
+  generateRawMessage,
+} from '~/utils/tests';
+
+import { convertFromRaw } from '../../utils';
+import { queryMessages } from '../../api';
+import { liveMessages } from '../../observers';
+
+describe('liveMessages', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const { subChannelId } = messages;
+  const returnValue = [{ messageId: messages.page1[0] }];
+  const rawMessage = generateRawMessage({
+    messageId: returnValue[0].messageId,
+    messageFeedId: subChannelId,
+  });
+  const message = convertFromRaw(rawMessage);
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is diabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+
+    const callback = jest.fn();
+    jest.spyOn(global.console, 'log');
+    client.http.get = jest.fn();
+
+    // call liveMessages check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveMessages({ subChannelId }, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return message collection', async () => {
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ subChannelId }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        // @ts-ignore
+        data: returnValue.map(convertFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should return error on api failure', async () => {
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveMessages({ subChannelId }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ subChannelId })).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        error,
+        data: [],
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should filter deleted messages based on param', async () => {
+    // mock response of queryMessages with a deleted message
+    const returnValue = [
+      { messageId: messages.page1[0], isDeleted: true },
+      { messageId: messages.page1[1], isDeleted: false },
+    ];
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ subChannelId, includeDeleted: false }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        // @ts-ignore
+        data: [returnValue[1]].map(convertFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const returnValue2 = [{ messageId: messages.page2[0] }];
+
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({
+        data: {
+          messages: returnValue,
+          paging: {
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messages: returnValue2,
+          paging: {
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+          },
+        },
+      });
+
+    liveMessages({ subChannelId }, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        // @ts-ignore
+        data: [...returnValue2, ...returnValue].map(convertFromRaw),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should add new message to collection onFetch', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ subChannelId }, callback);
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit('local.message.fetched', { messages: [message] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should add new message to collection onCreate', async () => {
+    const rawNewMessage = generateRawMessage({
+      messageId: 'new-message-id',
+      messageFeedId: message.subChannelId,
+    });
+    const newMessage = convertFromRaw(rawNewMessage);
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ subChannelId }, callback);
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      users: [],
+      files: [],
+    });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        error: undefined,
+        loading: false,
+      }),
+    );
+    expect(callback.mock.calls[2][0].data[0]).toMatchObject(newMessage);
+    expect(callback.mock.calls[2][0].data[1]).toMatchObject(returnValue[0]);
+  });
+
+  test('it should add new message to collection onUpdate', async () => {
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ subChannelId }, callback);
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('message.updated', {
+      messages: [rawMessage],
+      users: [],
+      files: [],
+    });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should add new message to collection onDelete', async () => {
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ subChannelId }, callback);
+
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('message.deleted', {
+      messages: [rawMessage],
+      users: [],
+      files: [],
+    });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+});

package/src/message/utils/index.ts

@@ -0,0 +1,140 @@
+import { AxiosResponse } from 'axios';
+import { toToken } from '~/core/query';
+import { pullFromCache } from '~/cache/api';
+import { prepareMessagePayloadForCache } from '~/reaction/utils/prepareMessagePayloadForCache';
+
+export function convertFromRaw({
+  channelPublicId,
+  childCount,
+  creatorPublicId,
+  mentionedUsers,
+  messageFeedId,
+  myReactions,
+  reactionCount,
+  reactions,
+  referenceId,
+  segment,
+  ...rest
+}: Amity.RawMessage): Amity.Message {
+  let cache: Amity.CacheEntry<Amity.Message> | undefined;
+
+  if (referenceId) {
+    try {
+      cache = pullFromCache(['message', 'get', referenceId]);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  if (!cache) {
+    try {
+      cache = pullFromCache(['message', 'get', rest.messageId]);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  const out: Amity.Message = {
+    ...rest,
+    channelId: channelPublicId,
+    channelSegment: segment,
+    childrenNumber: childCount,
+    creatorId: creatorPublicId,
+    reactions: reactions ?? {},
+    reactionsCount: reactionCount,
+    subChannelId: messageFeedId,
+    uniqueId: cache ? cache.data.uniqueId : rest.messageId,
+  };
+
+  if (mentionedUsers) {
+    out.mentionees = mentionedUsers.map(mention => {
+      if (mention.type === 'channel') {
+        return mention;
+      }
+
+      return { type: 'user', userIds: mention.userPublicIds };
+    });
+  }
+
+  if (myReactions) {
+    // http response
+    out.myReactions = myReactions;
+  } else {
+    // mqtt event
+    try {
+      prepareMessagePayloadForCache(out);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  return out;
+}
+
+export const prepareMessagePayload = (
+  payload: Amity.MessagePayload,
+): Amity.ProcessedMessagePayload => {
+  return {
+    ...payload,
+    messages: payload.messages.map(convertFromRaw),
+  };
+};
+
+export const convertResponseFromRaw = <T extends Amity.MessagePayload>(
+  response: AxiosResponse<T>,
+): AxiosResponse<Omit<T, 'messages'> & { messages: Amity.ProcessedMessagePayload['messages'] }> => {
+  return {
+    ...response,
+    data: {
+      ...response.data,
+      messages: response.data.messages.map(convertFromRaw),
+    },
+  };
+};
+
+type RawQueryMessages = Omit<
+  Amity.QueryMessages,
+  /*
+   * include deleted is for internal sdk use only. The server expects isDeleted
+   */
+  'page' | 'sortBy' | 'subChannelId' | 'tags' | 'includeDeleted'
+> & {
+  includeTags?: Amity.QueryMessages['tags'];
+  isDeleted?: Amity.Message['isDeleted'];
+  messageFeedId: Amity.QueryMessages['subChannelId'];
+  options: {
+    sortBy?: Amity.QueryMessages['sortBy'];
+    token: string;
+  };
+};
+
+export function convertParams({
+  subChannelId,
+  mentionees,
+  ...rest
+}: Partial<Amity.Message>): Record<string, any> {
+  return { messageFeedId: subChannelId, mentionedUsers: mentionees, ...rest };
+}
+
+export function convertQueryParams({
+  page,
+  sortBy,
+  subChannelId,
+  tags,
+  includeDeleted,
+  ...rest
+}: Amity.QueryMessages): RawQueryMessages {
+  const out: RawQueryMessages = {
+    ...rest,
+    messageFeedId: subChannelId,
+    isDeleted: includeDeleted === false ? false : undefined,
+    options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
+  };
+
+  if (sortBy !== undefined) {
+    out.options.sortBy = sortBy;
+  }
+
+  if (tags) {
+    out.includeTags = tags;
+  }
+
+  return out;
+}

package/src/poll/api/closePoll.ts

@@ -1,7 +1,11 @@
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: poll.close
+*/
 /**
  * ```js
  * import { closePoll } from '@amityco/ts-sdk'
@@ -30,6 +34,8 @@ export const closePoll = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  fireEvent('poll.updated', data);
+
   const { polls } = data;
 
   return {
@@ -37,3 +43,4 @@ export const closePoll = async (
     cachedAt,
   };
 };
+/* end_public_function */

package/src/poll/api/createPoll.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: poll.create
+*/
 /**
  * ```js
  * import { createPoll } from '@amityco/ts-sdk'
@@ -43,3 +46,4 @@ export const createPoll = async (
     cachedAt,
   };
 };
+/* end_public_function */

package/src/poll/api/deletePoll.ts

@@ -1,9 +1,13 @@
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 
 import { upsertInCache } from '~/cache/api';
 
 import { getPoll } from './getPoll';
 
+/* begin_public_function
+  id: poll.delete
+*/
 /**
  * ```js
  * import { deletePoll } from '@amityco/ts-sdk'
@@ -32,5 +36,8 @@ export const deletePoll = async (pollId: Amity.Poll['pollId']): Promise<boolean>
 
   upsertInCache(['poll', 'get', pollId], deleted);
 
+  fireEvent('poll.deleted', { polls: [deleted], users: [] });
+
   return success;
 };
+/* end_public_function */

package/src/poll/api/getPoll.ts

@@ -3,6 +3,9 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: poll.get
+*/
 /**
  * ```js
  * import { getPoll } from '@amityco/ts-sdk'
@@ -33,6 +36,7 @@ export const getPoll = async (pollId: Amity.Poll['pollId']): Promise<Amity.Cache
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/poll/api/tests/closePoll.test.ts

@@ -0,0 +1,50 @@
+import { client, pause, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { onPollUpdated } from '~/poll/events';
+import { closePoll } from '../closePoll';
+import { getPoll } from '../getPoll';
+
+describe('closePoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: b679db23-6a49-4858-ba53-2b64ced2f587
+  it('should close the poll', async () => {
+    client.http.put = jest
+      .fn()
+      .mockResolvedValueOnce({ data: { polls: [{ ...poll11, status: 'closed' }] } });
+    const callback = jest.fn();
+    onPollUpdated(callback);
+
+    const { data: poll } = await closePoll(poll11.pollId);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+    await pause();
+
+    expect(poll.status).toEqual('closed');
+    expect(cachedPoll).toMatchObject(poll);
+    expect(callback).toHaveBeenCalledWith(poll);
+  });
+
+  // integration_test_id: ec12e345-0e93-435b-9750-e81408fcb791
+  it('should fail to close if the poll does not exist', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => closePoll('non-existent-poll-id')).rejects.toThrow();
+  });
+
+  // integration_test_id: ed6ea62d-199c-4446-a3c3-554812707b42
+  it('should fail to close if user does not have permissions', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => closePoll('no-permissions-poll-id')).rejects.toThrow();
+  });
+});

package/src/poll/api/tests/createPoll.test.ts

@@ -0,0 +1,70 @@
+import { client, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { createPoll } from '../createPoll';
+import { getPoll } from '../getPoll';
+
+describe('createPoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  const bundle: Parameters<typeof createPoll>[0] = {
+    answerType: 'single',
+    answers: [
+      {
+        data: 'answer1',
+        dataType: 'text',
+      },
+      {
+        data: 'answer1',
+        dataType: 'text',
+      },
+    ],
+    question: 'question',
+  };
+
+  // integration_test_id: 5dc099fd-8e89-4f78-bf6c-fda6dbd06b66
+  it('should create a poll with a single answer', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await createPoll(bundle);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+
+    expect(poll.pollId).toBeDefined();
+    expect(cachedPoll).toMatchObject(poll);
+  });
+
+  // integration_test_id: d18d4f13-6ac5-42f1-822b-a22fc0a7cf90
+  it('should create a poll with multiple answers', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await createPoll({
+      ...bundle,
+      answerType: 'multiple',
+    });
+
+    expect(poll.pollId).toBeDefined();
+  });
+
+  // integration_test_id: 4cda145c-0bc8-4aaf-9ec0-02676bbde8a6
+  it('should fail if question exceeds 500 characters', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.BUSINESS_ERROR, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => createPoll(bundle)).rejects.toThrow();
+  });
+
+  // integration_test_id: a96780e1-758e-4de7-9c18-fdb34c4cacc7
+  it('should fail if question exceeds 200 characters', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.BUSINESS_ERROR, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => createPoll(bundle)).rejects.toThrow();
+  });
+});