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

package/src/subChannelRepository/api/readingAPI.ts

@@ -0,0 +1,42 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { SubChannel } from '@amityco/ts-sdk-react-native'
+ * const success = await SubChannel('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param messageFeedIds - Sub channel ID list to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const readingAPI = async (
+  messageFeedIds: Amity.SubChannel['subChannelId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('subChannel/readingAPI', messageFeedIds);
+
+  const { data: payload } = await client.http.post<Amity.ReadingPayload>(
+    `/api/v1/markers/message-feeds/reading`,
+    { messageFeedIds },
+  );
+
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.ReadingPayload, { cachedAt });
+
+  fireEvent('local.feedMarker.fetched', { feedMarkers });
+  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return true;
+};

package/src/subChannelRepository/api/softDeleteSubChannel.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+import { deleteSubChannel } from './deleteSubChannel';
+
+/* begin_public_function
+  id: subchannel.soft_delete
+*/
+/**
+ * ```js
+ * import { SubChannelRepository } from '@amityco/ts-sdk-react-native'
+ * const success = await SubChannelRepository.softDeleteSubChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.SubChannel}
+ *
+ * @param subChannelId The {@link Amity.SubChannel} ID to soft delete
+ * @return A success boolean if the {@link Amity.SubChannel} was soft deleted
+ *
+ * @category Channel API
+ * @async
+ */
+export const softDeleteSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Promise<Amity.SubChannel> => {
+  const client = getActiveClient();
+  client.log('channel/softDeleteSubChannel', subChannelId);
+
+  const softDelted = await deleteSubChannel(subChannelId, false);
+
+  return softDelted;
+};
+/* end_public_function */

package/src/subChannelRepository/api/startReadingAPI.ts

@@ -0,0 +1,41 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { SubChannel } from '@amityco/ts-sdk-react-native'
+ * const success = await SubChannel('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param messageFeedId - Sub channel ID to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const startReadingAPI = async (
+  messageFeedId: Amity.SubChannel['subChannelId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('subChannel/startReadingAPI', messageFeedId);
+
+  const { data: payload } = await client.http.post<Amity.StartReadingPayload>(
+    `/api/v1/markers/message-feeds/${messageFeedId}/start-reading`,
+  );
+
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StartReadingPayload, { cachedAt });
+
+  fireEvent('local.feedMarker.fetched', { feedMarkers });
+  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return true;
+};

package/src/subChannelRepository/api/stopReadingAPI.ts

@@ -0,0 +1,41 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk-react-native'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Mark all messages as read and stop reading message inside channel
+ *
+ * @param messageFeedId - The sub channel ID to stop reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const stopReadingAPI = async (
+  messageFeedId: Amity.SubChannel['subChannelId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/stopReadingAPI', messageFeedId);
+
+  const { data: payload } = await client.http.post<Amity.StopReadingPayload>(
+    `/api/v1/markers/message-feeds/${messageFeedId}/stop-reading`,
+  );
+
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StopReadingPayload, { cachedAt });
+
+  fireEvent('local.feedMarker.fetched', { feedMarkers });
+  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return true;
+};

package/src/subChannelRepository/api/tests/createSubChannel.test.ts

@@ -0,0 +1,113 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+
+import { onSubChannelCreated } from '~/subChannelRepository/events';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+import { createSubChannel } from '../createSubChannel';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  // integration_test_id: fa72f0eb-b22b-4b9a-9e55-3a163a0ebd2a
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.post = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await createSubChannel(subChannelPayload);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: f5b376b7-32b6-47f3-a5a1-553221340d17
+  test('it should return error 400400 when try to create subChannel from wrong parent channel Id', async () => {
+    const apiError = new ASCApiError(
+      'Channel not found.',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await createSubChannel({
+        channelId: 'invalid_channel_id',
+        displayName: 'sub channel name',
+      });
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 73b59e57-2330-4ed3-95bd-241c9e7a2c43
+  test('it should return error 400301 when try to create subChannel from channel Id which current user is not member', async () => {
+    const apiError = new ASCApiError(
+      'You are not a member of this channel.',
+      Amity.ServerError.PERMISSION_DENIED,
+      Amity.ErrorLevel.ERROR,
+    );
+    client.http.post = jest.fn().mockRejectedValue({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await createSubChannel({
+        channelId: 'invalid_channel_id',
+        displayName: 'sub channel name',
+      });
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.post = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await createSubChannel(subChannelPayload);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('should fire event `onSubChannelCreated`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.post = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelCreated(resolve);
+    }).finally(dispose);
+
+    const { data } = await createSubChannel(subChannelPayload);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

package/src/subChannelRepository/api/tests/deleteSubChannel.test.ts

@@ -0,0 +1,114 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+import { deleteSubChannel } from '../deleteSubChannel';
+import { onSubChannelDeleted } from '../../events';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+describe('deleteSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  // integration_test_id: 43ba1273-4560-4cea-93ce-cf5728b2a475
+  test('it should delete sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    const result = await deleteSubChannel(subChannelId);
+    expect(result.isDeleted).toEqual(true);
+  });
+
+  // integration_test_id: 57ba785f-484b-4f19-aa38-18e0bd4ec433
+  test('it should return error 400400 when try to delete subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await deleteSubChannel(subChannelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    await deleteSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(expect.objectContaining({ isDeleted: true }));
+  });
+
+  test('should fire event `onChannelDeleted`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    const rawDeleteSubChannel = generateRawSubChannel({ isDeleted: true });
+
+    // Mock for getSubChannel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    client.http.delete = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: [rawDeleteSubChannel],
+        messages: [],
+        users: [],
+        files: [],
+      },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelDeleted(resolve);
+    }).finally(dispose);
+
+    await deleteSubChannel(subChannelId);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining({ isDeleted: true }));
+  });
+});

package/src/subChannelRepository/api/tests/getSubChannel.test.ts

@@ -0,0 +1,99 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+import { getSubChannel } from '../getSubChannel';
+import { onSubChannelFetched } from '../../events/onSubChannelFetched';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('getSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  // integration_test_id: 6f019056-921e-43e2-a426-dd5a96f2fdcf
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannel(subChannelId);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 0dc440b6-b2bb-41fb-bbe8-1b2a4c71bffc
+  test('it should return error 400400 when try to get subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.put = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await getSubChannel(subChannelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('it should return a valid sub channel from locally cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    await getSubChannel(subChannelId);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+    const locallyData = await getSubChannel.locally(subChannelId);
+
+    expect(cache?.data).toEqual(locallyData?.data);
+  });
+
+  test('should fire event `onSubChannelFetched`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelFetched(resolve);
+    }).finally(dispose);
+
+    const { data } = await getSubChannel(subChannelId);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

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

@@ -0,0 +1,100 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+import { getSubChannels } from '../getSubChannels';
+import { onSubChannelFetched } from '../../events/onSubChannelFetched';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  // integration_test_id: dc771f42-14b9-420e-999d-858151e8ce41
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    expect(data[0].channelId).toEqual(subChannelPayload.channelId);
+    expect(data[0].displayName).toEqual(subChannelPayload.displayName);
+    expect(data[0].subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 28710df0-e5b6-4e46-b1aa-440d5ea01995
+  test('it should return error 400400 when try to get subChannel from invalid subChannelId', async () => {
+    const apiError = new ASCApiError(
+      'Feed not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      status: 404,
+      data: apiError,
+    });
+
+    try {
+      await getSubChannels([subChannelId]);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  test('it should return a valid sub channel from cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data[0]);
+  });
+
+  test('it should return a valid sub channel from locally cache', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    await getSubChannels([subChannelId]);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+    const locallyData = await getSubChannels.locally([subChannelId]);
+
+    expect(cache?.data).toEqual(locallyData?.data[0]);
+  });
+
+  test('should fire event `onSubChannelFetched`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelFetched(resolve);
+    }).finally(dispose);
+
+    const { data } = await getSubChannels([subChannelId]);
+
+    await expect(callbackPromise).resolves.toMatchObject(data[0]);
+  });
+});

package/src/subChannelRepository/api/tests/hardDeleteSubChannel.test.ts

@@ -0,0 +1,34 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+import { disableCache, enableCache } from '~/cache/api';
+
+import { hardDeleteSubChannel } from '../hardDeleteSubChannel';
+
+describe('softDeleteSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  /*
+   * this is the only test required as the rest are tested in
+   * deleteSubChannel.test.ts
+   */
+  test('it should call the api with the correct param', async () => {
+    const mockApi = jest.fn().mockResolvedValue({ data: {} });
+    const rawSubChannel = generateRawSubChannel();
+    const expected = { params: { permanent: true } };
+
+    // mock get sub channel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+    client.http.delete = mockApi;
+
+    await hardDeleteSubChannel('sub-channel-id');
+
+    const recieved = mockApi.mock.lastCall[1];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});

package/src/subChannelRepository/api/tests/softDeleteSubChannel.test.ts

@@ -0,0 +1,34 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+import { disableCache, enableCache } from '~/cache/api';
+
+import { softDeleteSubChannel } from '../softDeleteSubChannel';
+
+describe('softDeleteSubChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  /*
+   * this is the only test required as the rest are tested in
+   * deleteSubChannel.test.ts
+   */
+  test('it should call the api with the correct param', async () => {
+    const mockApi = jest.fn().mockResolvedValue({ data: {} });
+    const rawSubChannel = generateRawSubChannel();
+    const expected = { params: { permanent: false } };
+
+    // mock get sub channel
+    client.http.get = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+    client.http.delete = mockApi;
+
+    await softDeleteSubChannel('sub-channel-id');
+
+    const recieved = mockApi.mock.lastCall[1];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});