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

package/src/subChannel/api/querySubChannels.ts

@@ -0,0 +1,115 @@
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { getResolver } from '~/core/model';
+import { toPage, toToken } from '~/core/query';
+import { fireEvent } from '~/core/events';
+import { convertQueryParams, prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { querySubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await querySubChannels({ channelId: 'channelId' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.SubChannel} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const querySubChannels = async (
+  query: Amity.QuerySubChannels,
+): Promise<Amity.Cached<Amity.Paged<Amity.SubChannel>>> => {
+  const client = getActiveClient();
+  client.log('channel/querySubChannels', query);
+
+  const { page = { limit: 10 }, channelId, ...params } = convertQueryParams(query);
+
+  const response = await client.http.get<Amity.RawSubChannelPayload & Amity.Pagination>(
+    `/api/v5/message-feeds/channel/${channelId}`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = response.data;
+  const data = prepareSubChannelPayload(payload);
+  const subChannels = data.messageFeeds;
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data as Amity.SubChannelPayload, { cachedAt });
+
+    const cacheKey = [
+      'subChannel',
+      'query',
+      { channelId, ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { subChannels: subChannels.map(getResolver('subChannel')), paging });
+  }
+
+  fireEvent('local.message-feed.fetched', data);
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: subChannels, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { querySubChannels } from '@amityco/ts-sdk'
+ * const subChannels = querySubChannels.locally({ channelId: 'channelId' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.SubChannel} objects from cache
+ *
+ * @param query The query parameters
+ * @returns sub channels
+ *
+ * @category Channel API
+ */
+querySubChannels.locally = (
+  query: Parameters<typeof querySubChannels>[0],
+): Amity.Cached<Amity.Paged<Amity.SubChannel>> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/querySubChannels.locally', query);
+
+  // @ts-ignore
+  const { page = { limit: 10 }, channelId, ...params } = convertQueryParams(query) ?? {};
+
+  const cacheKey = [
+    'subChannel',
+    'query',
+    { channelId, ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        subChannels: Pick<Amity.SubChannel, 'subChannelId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.subChannels.length) return;
+
+  const subChannels: Amity.SubChannel[] = data.subChannels
+    .map(ck => pullFromCache<Amity.SubChannel>(['subChannel', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return subChannels.length === data?.subChannels?.length
+    ? { data: subChannels, cachedAt, prevPage, nextPage }
+    : undefined;
+};

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

@@ -0,0 +1,103 @@
+import { createSubChannel } from '../createSubChannel';
+import {
+  client,
+  generateRawSubChannel,
+  createSubChannelError400301,
+  createSubChannelError400400,
+} from '~/utils/tests';
+
+import { onSubChannelCreated } from '~/subChannel/events';
+
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+const subChannelId = 'channelId11--sub-channel-id';
+
+const subChannelPayload = {
+  channelId: 'channelId11',
+  displayName: 'sub channel name',
+};
+
+describe('createSubChannel', () => {
+  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 () => {
+    client.http.post = jest.fn().mockRejectedValue({
+      status: 404,
+      data: createSubChannelError400400,
+    });
+
+    try {
+      await createSubChannel({
+        channelId: createSubChannelError400400.data.detail.channelId,
+        displayName: 'sub channel name',
+      });
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(404);
+      expect(data).toEqual(createSubChannelError400400);
+    }
+  });
+
+  // integration_test_id: 73b59e57-2330-4ed3-95bd-241c9e7a2c43
+  test('it should return error 400301 when try to create subChannel from channel Id', async () => {
+    client.http.post = jest.fn().mockRejectedValue({
+      status: 403,
+      data: createSubChannelError400301,
+    });
+
+    try {
+      await createSubChannel({
+        channelId: createSubChannelError400301.data.detail.channelId,
+        displayName: 'sub channel name',
+      });
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(createSubChannelError400301);
+    }
+  });
+
+  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/subChannel/api/updateSubChannel.ts

@@ -0,0 +1,43 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { updateSubChannel } from '@amityco/ts-sdk'
+ * 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.RawSubChannelPayload>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { name: patch.displayName },
+  );
+  const data = 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,
+  };
+};

package/src/subChannel/events/index.ts

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

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());
+  };
+};