@amityco/ts-sdk 0.0.1-003998f.0

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

@@ -0,0 +1,248 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+} from '~/utils/constants';
+import { liveMessage } from '../../observers/liveMessage';
+import { createMessage } from '../../api';
+
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  messageQueryResponse,
+  message11 as defaultMessage,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: undefined as undefined | Amity.Message,
+  };
+};
+
+describe('liveMessage', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  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 liveMessage check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return message live object', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = defaultMessage;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return error on api failure', async () => {
+    const snapshot = getSnapshot();
+    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);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should terminate updates on api failure', async () => {
+    const snapshot = getSnapshot();
+    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);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+
+    const updatedAt = new Date(defaultMessage?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedMessage = {
+      ...defaultMessage,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('v3.message.didUpdate', { messages: [updatedMessage] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedMessage;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should not return updates on obtain once!', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+
+    const unsub = liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    unsub();
+
+    const updatedAt = new Date(defaultMessage?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedMessage = {
+      ...defaultMessage,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('v3.message.didUpdate', { messages: [updatedMessage] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedMessage;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events][] = [
+    ['it should return updated message on onFetch', 'v3.message.didFetch'],
+    ['it should return updated message on onUpdate', 'v3.message.didUpdate'],
+    ['it should return updated message on onDelete', 'v3.message.didDelete'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    const updatedAt = new Date(defaultMessage?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedMessage = {
+      ...defaultMessage,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit(event, { messages: [updatedMessage] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedMessage;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should terminate updates for unsynced object', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn();
+    const snapshot = getSnapshot();
+    const data = { channelId: 'test', data: { text: 'text' } };
+
+    const message = createMessage.optimistically(data);
+
+    const error = new ASCApiError(
+      UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+      Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    liveMessage(message!.data.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    snapshot.data = message!.data;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+});

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

@@ -0,0 +1,339 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { queryMessages } from '../../api';
+import { liveMessages } from '../../observers';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  messages,
+  message11 as defaultMessage,
+} from '~/utils/tests';
+
+describe('liveMessages', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const { channelId } = messages;
+  const returnValue = [{ messageId: messages.page1[0] }];
+  const message = { ...defaultMessage, messageId: returnValue[0].messageId, channelId };
+
+  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({ channelId }, 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({ channelId }, 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({ channelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: returnValue,
+        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({ channelId }, 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({ channelId })).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({ channelId, isDeleted: 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({ channelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [returnValue[1]],
+        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: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messages: returnValue2,
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    liveMessages({ channelId }, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryMessages({ channelId })).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({ channelId })).resolves.toBeTruthy();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        data: [...returnValue2, ...returnValue],
+        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({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit('v3.message.didFetch', { 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 newMessage = {
+      ...message,
+      messageId: 'new-messageId',
+    };
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('v3.message.didCreate', { messages: [newMessage] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [newMessage, ...returnValue],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  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({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('v3.message.didUpdate', { messages: [message] });
+
+    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({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('v3.message.didDelete', { messages: [message] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+});

package/src/poll/api/closePoll.ts

@@ -0,0 +1,42 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { closePoll } from '@amityco/ts-sdk'
+ * const updated = await closePoll(pollId)
+ * ```
+ *
+ * Updates an {@link Amity.Poll}
+ *
+ * @param pollId The ID of the {@link Amity.Poll} to close
+ * @returns the updated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const closePoll = async (
+  pollId: Amity.Poll['pollId'],
+): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('user/closePoll', pollId);
+
+  const { data } = await client.http.put<Amity.PollPayload>(
+    `/api/v3/polls/${encodeURIComponent(pollId)}`,
+    { status: 'closed' },
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('poll.updated', data);
+
+  const { polls } = data;
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};

package/src/poll/api/createPoll.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createPoll } from '@amityco/ts-sdk'
+ * const created = await createPoll({
+ *   question: 'question',
+ *   answers: [
+ *      { dataType: 'text', data: 'answer1' },
+ *      { dataType: 'text', data: 'answer2' },
+ *   ],
+ *   closedIn: 1649136484
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Poll}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Poll}
+ * @returns The newly created {@link Amity.Poll}
+ *
+ * @category Poll API
+ * @async
+ */
+export const createPoll = async (
+  bundle: Pick<Amity.Poll, 'question' | 'answerType' | 'closedIn'> & {
+    answers: Pick<Amity.PollAnswer, 'dataType' | 'data'>[];
+  },
+): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('post/createPoll', bundle);
+
+  const { data } = await client.http.post<Amity.PollPayload>('/api/v3/polls', bundle);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  return {
+    data: polls[0],
+    cachedAt,
+  };
+};

package/src/poll/api/deletePoll.ts

@@ -0,0 +1,39 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache } from '~/cache/api';
+
+import { getPoll } from './getPoll';
+
+/**
+ * ```js
+ * import { deletePoll } from '@amityco/ts-sdk'
+ * const success = await deletePoll(pollId)
+ * ```
+ *
+ * Deletes a {@link Amity.Poll}
+ *
+ * @param pollId The {@link Amity.Poll} ID to delete
+ * @return A success boolean if the {@link Amity.Poll} was deleted
+ *
+ * @category Poll API
+ * @async
+ */
+export const deletePoll = async (pollId: Amity.Poll['pollId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('poll/deletePoll', pollId);
+
+  const poll = await getPoll(pollId);
+
+  // API-FIX: it returns { success: boolean } but seems it should be Amity.Response<{ success: boolean }
+  const { data } = await client.http.delete<{ success: boolean }>(`/api/v3/polls/${pollId}`);
+
+  const { success } = data; // unwrapPayload(data)
+  const deleted = { ...poll.data, isDeleted: true };
+
+  upsertInCache(['poll', 'get', pollId], deleted);
+
+  fireEvent('poll.deleted', { polls: [deleted], users: [] });
+
+  return success;
+};