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

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

@@ -0,0 +1,89 @@
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
+
+import { onSubChannelUpdated } from '~/subChannelRepository/events';
+
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+
+import { updateSubChannel } from '../updateSubChannel';
+
+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: 9f50fa02-c26c-4666-8e8b-2d9076a3edd3
+  test('it should return a valid sub channel', async () => {
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    expect(data.channelId).toEqual(subChannelPayload.channelId);
+    expect(data.displayName).toEqual(subChannelPayload.displayName);
+    expect(data.subChannelId).toEqual(subChannelId);
+  });
+
+  // integration_test_id: 118f410c-5476-4c4e-9199-ac166da30840
+  test('it should return error 400400 when try to update subChannel from wrong sub channel Id', 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 updateSubChannel(subChannelId, {
+        displayName: 'sub channel name',
+      });
+    } 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 updateSubChannel(subChannelId, subChannelPayload);
+
+    const cache = pullFromCache(['subChannel', 'get', subChannelId]);
+
+    expect(cache?.data).toEqual(data);
+  });
+
+  test('should fire event `onSubChannelUpdated`', async () => {
+    let dispose;
+    const rawSubChannel = generateRawSubChannel();
+    client.http.put = jest.fn().mockResolvedValue({
+      data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] },
+    });
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelUpdated(resolve);
+    }).finally(dispose);
+
+    const { data } = await updateSubChannel(subChannelId, subChannelPayload);
+
+    await expect(callbackPromise).resolves.toMatchObject(data);
+  });
+});

package/src/subChannelRepository/api/updateSubChannel.ts

@@ -0,0 +1,47 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: subchannel.update
+*/
+/**
+ * ```js
+ * import { updateSubChannel } from '@amityco/ts-sdk-react-native'
+ * const updated = await updateSubChannel(subChannelId, { name: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.SubChannel}
+ *
+ * @param subChannelId The ID of the {@link Amity.SubChannel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const updateSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  patch: Patch<Amity.SubChannel, 'displayName'>,
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('channel/updateSubChannel', subChannelId, patch);
+
+  const response = await client.http.put<Amity.SubChannelPayload>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { name: patch.displayName },
+  );
+  const data = await prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('message-feed.updated', response.data);
+
+  return {
+    data: data.messageFeeds[0],
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/subChannelRepository/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onSubChannelCreated';
+export * from './onSubChannelUpdated';
+export * from './onSubChannelDeleted';

package/src/subChannelRepository/events/onSubChannelCreated.ts

@@ -0,0 +1,32 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelSubCreated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onSubChannelCreated(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onSubChannelCreated = (callback: Amity.Listener<Amity.SubChannel>) => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.SubChannelPayload) => {
+    const payload = await prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  return createEventSubscriber(client, 'onSubChannelCreated', 'message-feed.created', filter);
+};

package/src/subChannelRepository/events/onSubChannelDeleted.ts

@@ -0,0 +1,44 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onSubChannelDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onSubChannelDeleted(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onSubChannelDeleted = (callback: Amity.Listener<Amity.SubChannel>) => {
+  const client = getActiveClient();
+
+  const filter = async (rawPayload: Amity.SubChannelPayload) => {
+    const payload = await prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  const disposers = [
+    createEventSubscriber(client, 'onSubChannelDeleted', 'message-feed.deleted', filter),
+    createEventSubscriber(
+      client,
+      'local.message-feed.deleted',
+      'local.message-feed.deleted',
+      payload => callback(payload.messageFeeds[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannelRepository/events/onSubChannelFetched.ts

@@ -0,0 +1,12 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/** @hidden */
+export const onSubChannelFetched = (callback: Amity.Listener<Amity.SubChannel>) => {
+  return createEventSubscriber(
+    getActiveClient(),
+    'onSubChannelFetched',
+    'local.message-feed.fetched',
+    payload => callback(payload.messageFeeds[0]),
+  );
+};

package/src/subChannelRepository/events/onSubChannelUpdated.ts

@@ -0,0 +1,47 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onSubChannelUpdated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onSubChannelUpdated(subChannel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.SubChannel} have been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onSubChannelUpdated = (callback: Amity.Listener<Amity.SubChannel>) => {
+  const client = getActiveClient();
+
+  const subChannelChangeHandler = async (rawPayload: Amity.SubChannelPayload) => {
+    const payload = await prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  const disposers = [
+    createEventSubscriber(
+      client,
+      'onSubChannelUpdated',
+      'message-feed.updated',
+      subChannelChangeHandler,
+    ),
+    createEventSubscriber(client, 'onSubChannelUpdated', 'local.message-feed.updated', payload =>
+      callback(payload.messageFeeds[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannelRepository/index.ts

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './events';
+export * from './observers';
+export * from './utils/markReadEngine';

package/src/subChannelRepository/observers/getSubChannel.ts

@@ -0,0 +1,41 @@
+import { onSubChannelMarkerFetched } from '~/marker/events';
+import { convertEventPayload } from '~/utils/event';
+import { liveObject } from '~/utils/liveObject';
+import { getSubChannel as _getSubChannel } from '../api/getSubChannel';
+import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { onSubChannelFetched } from '../events/onSubChannelFetched';
+
+/* begin_public_function
+  id: subchannel.get
+*/
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk-react-native';
+ *
+ * let subChannel;
+ *
+ * const unsubscribe = getSubChannel(subChannelId, response => {
+ *   subChannel = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.SubChannel}
+ *
+ * @param subChannelId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channel
+ *
+ * @category SubChannel Live Object
+ */
+export const getSubChannel = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  callback: Amity.LiveObjectCallback<Amity.SubChannel>,
+): Amity.Unsubscriber => {
+  return liveObject(subChannelId, callback, 'subChannelId', _getSubChannel, [
+    onSubChannelFetched,
+    onSubChannelUpdated,
+    onSubChannelDeleted,
+    convertEventPayload(onSubChannelMarkerFetched, 'feedId', 'subChannel'),
+  ]);
+};
+/* end_public_function */

package/src/subChannelRepository/observers/getSubChannels.ts

@@ -0,0 +1,152 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  filterByPropEquality,
+  queryOptions,
+  runQuery,
+  sortByLastActivity,
+} from '~/core/query';
+import { onSubChannelMarkerFetched } from '~/marker/events';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onSubChannelFetched } from '~/subChannelRepository/events/onSubChannelFetched';
+import { shouldDispatchCollection, merge } from '~/utils';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { convertEventPayload } from '~/utils/event';
+import { convertGetterPropsToStatic } from '~/utils/object';
+import { onSubChannelCreated, onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { querySubChannels } from '../api/querySubChannels';
+
+/* begin_public_function
+  id: subchannel.query
+*/
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk-react-native';
+ *
+ * let subChannels = [];
+ *
+ * const unsubscribe = getSubChannels({ channelId }, response => {
+ *   merge(subChannels, response.data);
+ * });
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.SubChannel}s
+ *
+ * @param params for querying sub channels
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channels
+ *
+ * @category SubChannel Live Collection
+ */
+export const getSubChannels = (
+  params: Amity.SubChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.SubChannel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+  const timestamp = Date.now();
+  log(`getSubChannels(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...queryParams } = params;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  let snapshot: Amity.SubChannelLiveCollectionCache;
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const responder = (data: Amity.SubChannelLiveCollectionCache) => {
+    let subChannels: Amity.SubChannel[] = data.data;
+
+    if (!params.includeDeleted) {
+      subChannels = filterByPropEquality(subChannels, 'isDeleted', false);
+    }
+
+    subChannels.sort(sortByLastActivity);
+
+    callback({
+      onNextPage: onFetch,
+      data: subChannels,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.ChannelActionType) => (subChannel: Amity.SubChannel) => {
+    if (
+      params.channelId !== subChannel.channelId ||
+      !snapshot ||
+      !shouldDispatchCollection(snapshot.data, subChannel, action)
+    ) {
+      return;
+    }
+
+    if (action === 'onCreate') {
+      snapshot.data = [subChannel, ...snapshot.data];
+    } else {
+      snapshot.data = snapshot.data.map(x =>
+        x.subChannelId === subChannel.subChannelId ? subChannel : x,
+      );
+    }
+
+    snapshot.data = snapshot.data.map(convertGetterPropsToStatic);
+
+    responder(snapshot);
+  };
+
+  const onFetch = () => {
+    const subChannels = snapshot ? snapshot.data : [];
+
+    if (subChannels.length > 0 && !snapshot?.params.page) {
+      return;
+    }
+
+    const query = createQuery(querySubChannels, {
+      ...queryParams,
+      page: snapshot?.params.page ? { ...snapshot?.params.page, limit } : { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        snapshot = {
+          loading,
+          error,
+          params: { page },
+          data: result ? merge(subChannels, result.map(convertGetterPropsToStatic)) : subChannels,
+        };
+
+        responder(snapshot);
+      },
+      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
+    );
+  };
+
+  disposers.push(
+    onSubChannelCreated(realtimeRouter('onCreate')),
+    onSubChannelDeleted(realtimeRouter('onDelete')),
+    onSubChannelFetched(realtimeRouter('onFetch')),
+    onSubChannelUpdated(realtimeRouter('onUpdate')),
+    convertEventPayload(
+      onSubChannelMarkerFetched,
+      'feedId',
+      'subChannel',
+    )(realtimeRouter('onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`getSubChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/subChannelRepository/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './getSubChannel';
+export * from './getSubChannels';

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

@@ -0,0 +1,136 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawSubChannel,
+  convertSubChannelFromRaw,
+} from '~/utils/tests';
+import { createQuery, runQuery } from '~/core/query';
+import { deleteSubChannel, updateSubChannel } from '~/subChannelRepository/api';
+import { getSubChannel as _getSubChannel } from '~/subChannelRepository/api/getSubChannel';
+import { getFutureDate } from '~/core/model';
+import { getSubChannel } from '../getSubChannel';
+import * as getSubChannelMarkers from '../../../marker/api/getSubChannelMarkers';
+
+describe('getSubChannel', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const subChannel = convertSubChannelFromRaw(rawSubChannel);
+  const response = { data: { messageFeeds: [rawSubChannel], messages: [], users: [], files: [] } };
+
+  beforeAll(async () => {
+    await connectClient();
+
+    jest
+      .spyOn(getSubChannelMarkers, 'getSubChannelMarkers')
+      .mockResolvedValue({ data: [], cachedAt: undefined });
+  });
+
+  afterAll(disconnectClient);
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.Events][] = [
+    ['should get update on message-feed.updated event', 'message-feed.updated'],
+    ['should get update on message-feed.deleted event', 'message-feed.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...rawSubChannel,
+      name: event,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit(event, { messageFeeds: [update], messages: [], users: [], files: [] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: convertSubChannelFromRaw(update),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('should get an update without rte subscription', () => {
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    test('if _getSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest
+        .fn()
+        .mockResolvedValueOnce(response)
+        .mockResolvedValueOnce({
+          data: { messageFeeds: [update], messages: [], users: [], files: [] },
+        });
+
+      getSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await _getSubChannel(subChannel.subChannelId);
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertSubChannelFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if updateSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.put = jest.fn().mockResolvedValue({
+        data: { messageFeeds: [update], messages: [], users: [], files: [] },
+      });
+
+      getSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await updateSubChannel(subChannel.subChannelId, { displayName: update.name });
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertSubChannelFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if deleteSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.delete = jest.fn().mockResolvedValue({ data: { success: true } });
+
+      getSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      runQuery(createQuery(deleteSubChannel, subChannel.subChannelId));
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: { ...subChannel, isDeleted: true, updatedAt: expect.anything() },
+          loading: false,
+        }),
+      );
+    });
+  });
+});