@amityco/ts-sdk 0.0.1-beta.33 → 0.0.1-beta.36

package/src/subChannel/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'
+ * 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 = (rawPayload: Amity.RawSubChannelPayload) => {
+    const payload = prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  return createEventSubscriber(client, 'onSubChannelCreated', 'message-feed.created', filter);
+};

package/src/subChannel/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'
+ * 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 = (rawPayload: Amity.RawSubChannelPayload) => {
+    const payload = 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/subChannel/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/subChannel/events/onSubChannelUpdated.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 { onSubChannelUpdated } from '@amityco/ts-sdk'
+ * 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 filter = (rawPayload: Amity.RawSubChannelPayload) => {
+    const payload = prepareSubChannelPayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messageFeeds[0]);
+  };
+
+  return createEventSubscriber(client, 'onSubChannelUpdated', 'message-feed.updated', filter);
+};

package/src/subChannel/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './liveSubChannel';
+export * from './liveSubChannels';

package/src/subChannel/observers/liveSubChannel.ts

@@ -0,0 +1,84 @@
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery } from '~/core/query';
+import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { hasUpdates } from '~/core/model';
+import { getSubChannel } from '../api';
+import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { onSubChannelFetched } from '../events/onSubChannelFetched';
+
+/**
+ * ```js
+ * import { liveSubChannel } from '@amityco/ts-sdk';
+ *
+ * let subChannel;
+ *
+ * const unsubscribe = liveSubChannel(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 liveSubChannel = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  callback: Amity.LiveObjectCallback<Amity.SubChannel>,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+  const timestamp = Date.now();
+  log(`liveSubChannel(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  }
+
+  let subChannel: Amity.SubChannel;
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveObject<Amity.SubChannel>) => {
+    subChannel = data.data;
+    callback(data);
+  };
+
+  const realtimeRouter = (eventSubChannel: Amity.SubChannel) => {
+    if (subChannelId !== eventSubChannel.subChannelId) {
+      return;
+    }
+
+    if (subChannel && !hasUpdates(subChannel, eventSubChannel)) {
+      return;
+    }
+
+    dispatcher({ loading: false, data: eventSubChannel, origin: 'event' });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(getSubChannel, subChannelId);
+
+    runQuery(query, ({ error, data, loading, origin }) => {
+      dispatcher({ error, data, loading, origin });
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(
+    onSubChannelFetched(realtimeRouter),
+    onSubChannelUpdated(realtimeRouter),
+    onSubChannelDeleted(realtimeRouter),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveSubChannel(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannel/observers/liveSubChannels.ts

@@ -0,0 +1,137 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastActivity,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onSubChannelFetched } from '~/subChannel/events/onSubChannelFetched';
+import { isCollectionOutdated, merge } from '~/utils';
+import { onSubChannelCreated, onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { querySubChannels } from '../api';
+
+/**
+ * ```js
+ * import { liveSubChannels } from '@amityco/ts-sdk';
+ *
+ * let subChannels = [];
+ *
+ * const unsubscribe = liveSubChannels({ 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 liveSubChannels = (
+  params: Amity.SubChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.SubChannel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+  const timestamp = Date.now();
+  log(`liveSubChannels(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.isDeleted !== undefined) {
+      subChannels = filterByPropEquality(subChannels, 'isDeleted', params.isDeleted);
+    }
+
+    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 ||
+      !isCollectionOutdated(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,
+      );
+    }
+
+    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 ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        snapshot = {
+          loading,
+          error,
+          params: { page },
+          data: result ? merge(subChannels, result) : subChannels,
+        };
+
+        responder(snapshot);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onSubChannelCreated(realtimeRouter('onCreate')),
+    onSubChannelDeleted(realtimeRouter('onDelete')),
+    onSubChannelFetched(realtimeRouter('onFetch')),
+    onSubChannelUpdated(realtimeRouter('onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveSubChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannel/observers/tests/liveSubChannel.test.ts

@@ -0,0 +1,212 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { createQuery, runQuery } from '~/core/query';
+import { deleteSubChannel, getSubChannel, updateSubChannel } from '~/subChannel/api';
+import { getFutureDate } from '~/core/model';
+import { liveSubChannel } from '../liveSubChannel';
+import { convertFromRaw } from '../../utils';
+
+describe('liveSubChannel', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const subChannel = convertFromRaw(rawSubChannel);
+  const response = { data: { messageFeeds: [rawSubChannel] } };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should get sub channel', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(rawSubChannel.messageFeedId, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ data: undefined, loading: true }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: convertFromRaw(rawSubChannel),
+        loading: false,
+      }),
+    );
+  });
+
+  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);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit(event, { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: convertFromRaw(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] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await getSubChannel(subChannel.subChannelId);
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(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] } });
+
+      liveSubChannel(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: convertFromRaw(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 } });
+
+      liveSubChannel(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,
+        }),
+      );
+    });
+  });
+
+  test('should not get update on api failure', async () => {
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit('message-feed.updated', { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: undefined,
+        error,
+        loading: false,
+      }),
+    );
+  });
+
+  test('should not call callback if liveMessage is disposed', async () => {
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const dispose = liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    dispose();
+    client.emitter.emit('message-feed.updated', { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+
+  test('should not call callback if data is the same', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit('message-feed.updated', { messageFeeds: response.data.messageFeeds });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+});