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

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

@@ -0,0 +1,370 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  messages,
+  generateRawMessage,
+  convertRawMessage,
+  pause,
+} from '~/utils/tests';
+
+import { queryMessages } from '../../api/queryMessages';
+import { getMessages } from '../getMessages';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+describe('getMessages', () => {
+  beforeAll(() => {
+    connectClient();
+
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { subChannelId } = messages;
+  const returnValue: Amity.RawMessage[] = [generateRawMessage({ messageId: messages.page1[0] })];
+  const rawMessage = generateRawMessage({
+    messageId: returnValue[0].messageId,
+    messageFeedId: subChannelId,
+  });
+  const message = convertRawMessage(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 getMessages check if mocked console get's called with the correct
+    // message
+    client.use();
+    getMessages({ 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: {},
+      },
+    });
+
+    getMessages({ 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({
+        data: returnValue.map(convertRawMessage),
+        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);
+
+    getMessages({ 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: {},
+      },
+    });
+
+    getMessages({ 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(convertRawMessage),
+        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',
+          },
+        },
+      });
+
+    getMessages({ subChannelId, includeDeleted: true }, 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(convertRawMessage),
+        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: {},
+      },
+    });
+
+    getMessages({ 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 = convertRawMessage(rawNewMessage);
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ 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: [],
+      reactions: [],
+    });
+
+    await pause();
+
+    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(message);
+  });
+
+  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: {},
+      },
+    });
+
+    getMessages({ 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: [],
+      reactions: [],
+    });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      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: {},
+      },
+    });
+
+    getMessages({ 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: [],
+      reactions: [],
+    });
+
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+});

package/src/messageRepository/utils/getMessageReadCount.ts

@@ -0,0 +1,25 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getResolver } from '~/core/model';
+
+const getCachedMarker = (message: Amity.Message | Amity.RawMessage) => {
+  const key = {
+    creatorId: message.creatorId,
+    feedId: (<Amity.RawMessage>message).messageFeedId ?? (<Amity.Message>message).subChannelId,
+    contentId: message.messageId,
+  };
+
+  return pullFromCache<Amity.MessageMarker>([
+    'messageMarker',
+    'get',
+    getResolver('messageMarker')(key),
+  ])?.data;
+};
+
+export const getMessageReadCount = (
+  message: Amity.Message | Amity.RawMessage,
+  marker?: Amity.MessageMarker,
+) =>
+  // Look in the marker param first
+  marker ??
+  // If the marker param is not set, look in the cache
+  getCachedMarker(message) ?? { readCount: 0, deliveredCount: 0 }; // and if not found in cache use default value `0`

package/src/messageRepository/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareMessagePayload';

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -0,0 +1,163 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { toToken } from '~/core/query';
+import { getMessageMarkers } from '~/marker/api';
+import { prepareMessagePayloadForCache } from '~/reactionRepository/utils/prepareMessagePayloadForCache';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+import { getMessageReadCount } from './getMessageReadCount';
+
+export function convertFromRaw(
+  message: Amity.RawMessage,
+  reactors?: Amity.Reactor[],
+  event?: keyof Amity.MqttMessageEvents,
+): Amity.Message {
+  const {
+    channelPublicId,
+    childCount,
+    creatorPublicId,
+    mentionedUsers,
+    messageFeedId,
+    myReactions,
+    reactionCount,
+    reactions,
+    referenceId,
+    segment,
+    messageId,
+    ...rest
+  } = message;
+
+  let cache: Amity.CacheEntry<Amity.Message> | undefined;
+
+  if (referenceId) {
+    cache = pullFromCache(['message', 'get', referenceId]);
+  }
+
+  if (!cache) {
+    cache = pullFromCache(['message', 'get', messageId]);
+  }
+
+  const out: Amity.Message = {
+    get readCount() {
+      return getMessageReadCount(message).readCount;
+    },
+    get deliveredCount() {
+      return getMessageReadCount(message).deliveredCount;
+    },
+    ...rest,
+    messageId,
+    channelId: channelPublicId,
+    channelSegment: segment,
+    childrenNumber: childCount,
+    creatorId: creatorPublicId,
+    reactions: reactions ?? {},
+    /*
+     * Previously, myReactions were added only if it was part of the payload.
+     * So empty myReactions were not present. So I've edited the payload to add
+     * a default for those cases.
+     *
+     * Check git blame for previous iteration
+     */
+    myReactions: myReactions ?? [],
+    reactionsCount: reactionCount,
+    subChannelId: messageFeedId,
+    uniqueId: cache ? cache.data.uniqueId : messageId,
+    referenceId,
+  };
+
+  if (mentionedUsers) {
+    out.mentionees = mentionedUsers.map(mention => {
+      if (mention.type === 'channel') {
+        return mention;
+      }
+
+      return { type: 'user', userIds: mention.userPublicIds };
+    });
+  }
+
+  if (reactors && reactors.length && event) {
+    // mqtt event
+    prepareMessagePayloadForCache(out, reactors, event);
+  }
+
+  return out;
+}
+
+const preUpdateMessageCache = (rawPayload: Amity.MessagePayload) => {
+  ingestInCache({
+    messages: rawPayload.messages.map(message => convertFromRaw(message, rawPayload.reactions)),
+  });
+};
+
+export const prepareMessagePayload = async (
+  payload: Amity.MessagePayload,
+  event?: keyof Amity.MqttMessageEvents,
+): Promise<Amity.ProcessedMessagePayload> => {
+  const markerIds = payload.messages.map(({ messageId }) => messageId);
+
+  if (markerIds.length > 0) {
+    // since the get markers method requires a channel cache to function with the reducer.
+    preUpdateMessageCache(payload);
+
+    try {
+      await getMessageMarkers(markerIds);
+    } catch (e) {
+      // empty block (from the spec, allow marker fetch to fail without having to do anything)
+    }
+  }
+
+  return {
+    ...payload,
+    messages: payload.messages.map(m => convertFromRaw(m, payload.reactions, event)),
+  };
+};
+
+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: inferIsDeleted(includeDeleted),
+    options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
+  };
+
+  if (sortBy !== undefined) {
+    out.options.sortBy = sortBy;
+  }
+
+  if (tags) {
+    out.includeTags = tags;
+  }
+
+  return out;
+}

package/src/pollRepository/api/closePoll.ts

@@ -0,0 +1,46 @@
+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-react-native'
+ * 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,
+  };
+};
+/* end_public_function */

package/src/pollRepository/api/createPoll.ts

@@ -0,0 +1,49 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: poll.create
+*/
+/**
+ * ```js
+ * import { createPoll } from '@amityco/ts-sdk-react-native'
+ * 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,
+  };
+};
+/* end_public_function */

package/src/pollRepository/api/deletePoll.ts

@@ -0,0 +1,43 @@
+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-react-native'
+ * 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;
+};
+/* end_public_function */