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

package/src/subChannelRepository/observers/tests/getSubChannels.test.ts

@@ -0,0 +1,229 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  generateRawSubChannel,
+  convertSubChannelFromRaw,
+} from '~/utils/tests';
+import { getFutureDate, getPastDate } from '~/core/model';
+import * as getSubChannelMarkers from '~/marker/api/getSubChannelMarkers';
+import { getSubChannels } from '../getSubChannels';
+
+describe('getSubChannels', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const response = {
+    data: {
+      messageFeeds: [rawSubChannel],
+      messages: [],
+      users: [],
+      files: [],
+      paging: {},
+    },
+  };
+
+  beforeAll(async () => {
+    await connectClient();
+
+    jest
+      .spyOn(getSubChannelMarkers, 'getSubChannelMarkers')
+      .mockResolvedValue({ data: [], cachedAt: undefined });
+  });
+
+  afterAll(disconnectClient);
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('should get sub channels', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        loading: true,
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(rawSubChannel)],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should filter deleted sub channels based on params', async () => {
+    const rawSubChannels = [
+      generateRawSubChannel({ isDeleted: true }),
+      generateRawSubChannel({ messageFeedId: 'sub-channel-id-2' }),
+    ];
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: rawSubChannels,
+        messages: [],
+        users: [],
+        files: [],
+        paging: {},
+      },
+    });
+
+    getSubChannels({ channelId: rawSubChannel.channelPublicId, includeDeleted: false }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertSubChannelFromRaw(rawSubChannels[1])],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should fetch next page', async () => {
+    const rawSubChannel2 = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getPastDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel],
+          messages: [],
+          users: [],
+          files: [],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel2],
+          messages: [],
+          users: [],
+          files: [],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    getSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+    callback.mock.lastCall[0].onNextPage();
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        hasNextPage: true,
+        onNextPage: expect.anything(),
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        data: [rawSubChannel, rawSubChannel2].map(data => convertSubChannelFromRaw(data)),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('events', () => {
+    const newRawSubChannel = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getFutureDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const updatedRawSubChannel = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const deletedRawSubChannel = {
+      ...rawSubChannel,
+      isDeleted: true,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.RawSubChannel, Amity.SubChannel[]][] = [
+      [
+        'should add new sub channel to collection onCreate',
+        'message-feed.created',
+        newRawSubChannel,
+        [newRawSubChannel, rawSubChannel].map(data => convertSubChannelFromRaw(data)),
+      ],
+      [
+        'should remove sub channel from collection onDelete',
+        'message-feed.deleted',
+        deletedRawSubChannel,
+        [],
+      ],
+      [
+        'should update sub channel in collection onUpdate',
+        'message-feed.updated',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(data => convertSubChannelFromRaw(data)),
+      ],
+      [
+        'should update sub channel in collection onFetch',
+        'local.message-feed.fetched',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(data => convertSubChannelFromRaw(data)),
+      ],
+    ];
+
+    type testHandlerType = (...args: typeof cases[number]) => Promise<void>;
+    const testHandler: testHandlerType = async (test, event, rawEventSubChannel, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+
+      getSubChannels({ channelId: rawSubChannel.channelPublicId, includeDeleted: false }, callback);
+      await pause();
+      if (event === 'local.message-feed.fetched') {
+        pushToCache(
+          ['subChannel', 'get', rawEventSubChannel.messageFeedId],
+          convertSubChannelFromRaw(rawEventSubChannel),
+        );
+        client.emitter.emit(event, {
+          messageFeeds: [convertSubChannelFromRaw(rawEventSubChannel)],
+          messages: [],
+          users: [],
+          files: [],
+        });
+      } else {
+        client.emitter.emit(event, {
+          messageFeeds: [rawEventSubChannel],
+          messages: [],
+          users: [],
+          files: [],
+        });
+      }
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: expected,
+          loading: false,
+        }),
+      );
+    };
+
+    test.each(cases)('%s', testHandler);
+  });
+});

package/src/subChannelRepository/utils/getSubChannelUnreadCount.ts

@@ -0,0 +1,34 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getActiveUser } from '~/client/api/activeUser';
+import { getResolver } from '~/core/model';
+
+export function getSubChannelUnreadCount(
+  channelId: string,
+  subChannelId: string,
+  marker?: Amity.SubChannelMarker,
+) {
+  // Look for `unreadCount` in the marker param first
+  if (marker) {
+    return marker.unreadCount;
+  }
+
+  const key = {
+    entityId: channelId,
+    feedId: subChannelId,
+    userId: getActiveUser()._id,
+  };
+
+  // If the marker param is not set, look in the cache
+  const cachedMarker = pullFromCache<Amity.SubChannelMarker>([
+    'subChannelMarker',
+    'get',
+    getResolver('subChannelMarker')(key),
+  ])?.data;
+
+  if (cachedMarker) {
+    return cachedMarker.unreadCount;
+  }
+
+  // and if not found in cache use default value `0`
+  return 0;
+}

package/src/subChannelRepository/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './prepareSubChannelPayload';
+export * from './markReadEngine';

package/src/subChannelRepository/utils/markReadEngine.ts

@@ -0,0 +1,163 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import { getMarkedMessageTopic, subscribeTopic } from '~/core/subscription';
+import { setIntervalTask } from '~/utils/timer';
+
+import { onOnline } from '~/client/utils/onOnline';
+import { getSubChannel } from '../api/getSubChannel';
+import { readingAPI } from '../api/readingAPI';
+import { startReadingAPI } from '../api/startReadingAPI';
+import { stopReadingAPI } from '../api/stopReadingAPI';
+
+const START_READING_INTERVAL_TIME = 30000;
+
+let clearIntervalTask: Amity.Unsubscriber | null = null;
+let disposers: (() => void)[] = [];
+
+/**
+ * map contains subChannelId and isReading flag to determine which subChannel is on reading state
+ */
+const isReadingMap: Record<string, boolean> = {};
+
+const getReadingSubChannels = () => {
+  return Object.entries(isReadingMap)
+    .filter(([, value]) => value)
+    .map(([key]) => key);
+};
+
+/**
+ * call start reading API with reading list
+ */
+const startReadingFromReadingList = async () => {
+  const isReadingSubChannelIds = getReadingSubChannels();
+
+  if (isReadingSubChannelIds.length === 0) {
+    // no subChannel that require to call start reading API
+    return false;
+  }
+
+  return readingAPI(isReadingSubChannelIds);
+};
+
+const startIntervalTask = () => {
+  if (clearIntervalTask === null) {
+    clearIntervalTask = setIntervalTask(startReadingFromReadingList, START_READING_INTERVAL_TIME);
+  }
+};
+
+const stopIntervalTask = () => {
+  clearIntervalTask?.();
+  clearIntervalTask = null;
+};
+
+/**
+ * global task for mark read engines runs when the client is authenticated.
+ *
+ * NOTE: This task will be refactored again in the future. When the session component improved
+ * Relate Ticket: https://ekoapp.atlassian.net/browse/ASC-13542
+ */
+export const markReadEngineOnLoginHandler = () => {
+  startIntervalTask();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.NOT_LOGGED_IN) {
+      stopIntervalTask();
+    }
+  });
+
+  return () => {
+    stopIntervalTask();
+  };
+};
+
+const getParentChannelId = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Promise<Amity.SubChannel['channelId']> => {
+  const cached = getSubChannel.locally(subChannelId);
+
+  if (cached) {
+    return cached.data.channelId;
+  }
+
+  const { data } = await getSubChannel(subChannelId);
+  return data.channelId;
+};
+
+const registerEventListeners = () => {
+  disposers.push(
+    onOnline(() => {
+      // Start reading the reading subChannel again when resume from offline state
+      startReadingFromReadingList();
+    }),
+  );
+};
+
+const registerTopicSubscribers = async (subChannelId: Amity.SubChannel['subChannelId']) => {
+  const channelId = await getParentChannelId(subChannelId);
+  const markedMessageTopic = getMarkedMessageTopic({ channelId, subChannelId });
+  disposers.push(subscribeTopic(markedMessageTopic));
+};
+
+const disposeAll = () => {
+  disposers.forEach(fn => fn());
+  disposers = [];
+};
+
+/* begin_public_function
+  id: subchannel.start_reading
+*/
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk-react-native'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Set local reading state of channel to `true` and then call mark all
+ * messages as read API.
+ *
+ * @param subChannelId - The sub channel ID to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ */
+export const startReading = async (subChannelId: Amity.SubChannel['subChannelId']) => {
+  isReadingMap[subChannelId] = true;
+
+  if (disposers.length === 0) {
+    registerEventListeners();
+    registerTopicSubscribers(subChannelId);
+  }
+
+  try {
+    return await startReadingAPI(subChannelId);
+  } catch (e) {
+    isReadingMap[subChannelId] = false;
+    return false;
+  }
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: subchannel.stop_reading
+*/
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk-react-native'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Set local reading state of channel to `false` and then call mark all
+ * messages as unread API.
+ *
+ * @param subChannelId - The sub channel ID to stop reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ */
+export const stopReading = (subChannelId: Amity.SubChannel['subChannelId']) => {
+  isReadingMap[subChannelId] = false;
+  disposeAll();
+  return stopReadingAPI(subChannelId);
+};
+/* end_public_function */

package/src/subChannelRepository/utils/prepareSubChannelPayload.ts

@@ -0,0 +1,95 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getSubChannelMarkers } from '~/marker/api';
+import { convertFromRaw as convertMessageFromRaw } from '~/messageRepository/utils/prepareMessagePayload';
+
+import { getSubChannelUnreadCount } from './getSubChannelUnreadCount';
+
+export const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+
+/**
+ * Filter sub channel by type. Only conversation, community and broadcast type are included.
+ */
+export const isUnreadCountSupport = ({ channelType }: Pick<Amity.RawSubChannel, 'channelType'>) =>
+  MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
+
+export function convertFromRaw({
+  channelId,
+  channelPublicId,
+  channelType,
+  childCount,
+  creatorId,
+  creatorPublicId,
+  lastMessageId,
+  lastMessageTimestamp,
+  messageFeedId,
+  name,
+  ...rest
+}: Amity.RawSubChannel): Amity.SubChannel {
+  return {
+    get unreadCount() {
+      return getSubChannelUnreadCount(channelId, messageFeedId);
+    },
+    ...rest,
+    channelId: channelPublicId,
+    creatorId: creatorPublicId,
+    displayName: name,
+    lastActivity: lastMessageTimestamp,
+    latestMessageId: lastMessageId,
+    messageCount: childCount,
+    subChannelId: messageFeedId,
+    isUnreadCountSupport: isUnreadCountSupport({ channelType }),
+  };
+}
+
+const preUpdateSubChannelCache = (rawPayload: Amity.SubChannelPayload) => {
+  ingestInCache({
+    messageFeeds: rawPayload.messageFeeds.map(messageFeed => convertFromRaw(messageFeed)),
+  });
+};
+
+export const prepareSubChannelPayload = async (
+  rawPayload: Amity.SubChannelPayload,
+): Promise<Amity.ProcessedSubChannelPayload> => {
+  const markerIds = rawPayload.messageFeeds
+    .filter(isUnreadCountSupport)
+    .map(({ messageFeedId }) => messageFeedId);
+
+  if (markerIds.length > 0) {
+    // since the get markers method requires a channel cache to function with the reducer.
+    preUpdateSubChannelCache(rawPayload);
+
+    try {
+      await getSubChannelMarkers(markerIds);
+    } catch (e) {
+      // empty block (from the spec, allow marker fetch to fail without having to do anything)
+    }
+  }
+
+  // attach marker to sub channel
+  const messageFeeds = rawPayload.messageFeeds.map(convertFromRaw);
+
+  const messages = rawPayload.messages.map(m => convertMessageFromRaw(m));
+
+  return {
+    ...rawPayload,
+    messageFeeds,
+    messages,
+  };
+};
+
+type RawQuerySubChannels = Omit<Amity.QuerySubChannels, 'excludeDefaultSubChannel'> & {
+  excludeDefaultMessageFeed?: Amity.QuerySubChannels['excludeDefaultSubChannel'];
+};
+
+export function convertQueryParams({
+  excludeDefaultSubChannel,
+  ...rest
+}: Amity.QuerySubChannels): RawQuerySubChannels {
+  const out: RawQuerySubChannels = { ...rest };
+
+  if (excludeDefaultSubChannel !== undefined) {
+    out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+  }
+
+  return out;
+}

package/src/userRepository/api/flagUser.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/* begin_public_function
+  id: user.flag
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk-react-native'
+ * const flagged = await UserRepository.flagUser('userId')
+ * ```
+ *
+ * @param userId The ID of the user to add a be flagged
+ * @returns the created report result
+ *
+ * @category User API
+ * @async
+ * */
+export const flagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('user/flagUser', userId);
+
+  const { data: payload } = await client.http.post<Amity.UserPayload>(
+    `api/v4/me/flags/${encodeURIComponent(userId)}`,
+  );
+
+  if (client.cache) {
+    ingestInCache(payload);
+  }
+
+  fireEvent('user.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/userRepository/api/getUser.ts

@@ -0,0 +1,78 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+/**
+ * ```js
+ * import { getUser } from '~/user/api'
+ * const { data: user } = await getUser('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category Private
+ * @async
+ */
+export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/getUser', userId);
+
+  isInTombstone('user', userId);
+
+  let data: Amity.UserPayload;
+
+  try {
+    const response = await client.http.get<Amity.UserPayload>(
+      `/api/v3/users/${encodeURIComponent(userId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('user', userId);
+    }
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { users } = data;
+
+  fireEvent('user.fetched', data);
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk-react-native'
+ * const { data: user } = getUser.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object from cache
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ */
+getUser.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.User> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getUser.locally', userId);
+
+  return client.cache && pullFromCache<Amity.User>(['user', 'get', userId]);
+};