@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/streamRepository/observers/tests/getStreamById.test.ts

@@ -0,0 +1,44 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, pause, streamResponse } from '~/utils/tests';
+import { getStreamById } from '../getStreamById';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: undefined as undefined | Amity.InternalStream,
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('getStreamById', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('Should return the stream from backend', async () => {
+    enableCache();
+    const snapshot = getSnapshot();
+    const update = getSnapshot({ data: streamResponse.data.videoStreamings[0], loading: false });
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(streamResponse);
+
+    getStreamById(STREAM_ID, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(snapshot));
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(update));
+  });
+
+  test('Should return stream from locally', async () => {
+    const stream: ReturnType<typeof getStreamById.locally> = getStreamById.locally(STREAM_ID);
+    expect(stream?.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/subChannelRepository/api/createSubChannel.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: subchannel.create
+*/
+/**
+ * ```js
+ * import { createSubChannel } from '@amityco/ts-sdk'
+ * const created = await createSubChannel({ channelId: 'foobar', name: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.SubChannel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.SubChannel}
+ * @returns The newly created {@link Amity.SubChannel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const createSubChannel = async <T extends Amity.ChannelType>(
+  bundle: Pick<Amity.SubChannel, 'channelId' | 'displayName'>,
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('user/createSubChannel', bundle);
+
+  const response = await client.http.post<Amity.SubChannelPayload>('/api/v5/message-feeds', {
+    channelId: bundle.channelId,
+    name: bundle.displayName,
+  });
+  const data = await prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('message-feed.created', response.data);
+
+  return {
+    data: data.messageFeeds[0],
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/subChannelRepository/api/deleteSubChannel.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+import { getFutureDate } from '~/core/model';
+import { getSubChannel } from './getSubChannel';
+
+/**
+ * ```js
+ * import { deleteSubChannel } from '~/subChannelRepository/api/deleteSubChannel'
+ * const success = await deleteSubChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.SubChannel}
+ *
+ * @param subChannelId The {@link Amity.SubChannel} ID to delete
+ * @return A the {@link Amity.SubChannel} was deleted
+ *
+ * @private
+ * @async
+ */
+export const deleteSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  permanent = false,
+): Promise<Amity.SubChannel> => {
+  const client = getActiveClient();
+
+  const subChannel = await getSubChannel(subChannelId);
+
+  await client.http.delete<{ success: boolean }>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { params: { permanent } },
+  );
+
+  const deleted = {
+    ...subChannel.data,
+    isDeleted: true,
+    updatedAt: getFutureDate(subChannel.data.updatedAt),
+  };
+
+  if (permanent) {
+    setTimeout(() => {
+      pushToTombstone('subChannel', subChannelId);
+    }, 0);
+  } else {
+    upsertInCache(['subChannel', 'get', subChannelId], deleted);
+  }
+
+  fireEvent('local.message-feed.deleted', { messageFeeds: [deleted] });
+
+  return deleted;
+};

package/src/subChannelRepository/api/getSubChannel.ts

@@ -0,0 +1,86 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+
+import { prepareSubChannelPayload } from '../utils/prepareSubChannelPayload';
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = await getSubChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const getSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannel', subChannelId);
+
+  isInTombstone('subChannel', subChannelId);
+
+  try {
+    const response = await client.http.get<Amity.SubChannelPayload>(
+      `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    );
+    const data = await prepareSubChannelPayload(response.data);
+
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) ingestInCache(data, { cachedAt });
+
+    fireEvent('local.message-feed.fetched', data);
+
+    return {
+      data: data.messageFeeds[0],
+      cachedAt,
+    };
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('subChannel', subChannelId);
+    }
+
+    throw error;
+  }
+};
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = getSubChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object from cache
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ */
+getSubChannel.locally = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Amity.Cached<Amity.SubChannel> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannel.locally', subChannelId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/subChannelRepository/api/getSubChannels.ts

@@ -0,0 +1,78 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await getSubChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const getSubChannels = async (
+  subChannelIds: Amity.SubChannel['subChannelId'][],
+): Promise<Amity.Cached<Amity.SubChannel[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannels', subChannelIds);
+
+  const response = await client.http.get<Amity.SubChannelPayload>('/api/v5/message-feeds/list', {
+    params: { messageFeedIds: subChannelIds.map(encodeURIComponent) },
+  });
+
+  const data = await prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('local.message-feed.fetched', data);
+
+  return {
+    data: data.messageFeeds,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = getSubChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects from cache
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ */
+getSubChannels.locally = (
+  subChannelIds: Amity.SubChannel['subChannelId'][],
+): Amity.Cached<Amity.SubChannel[]> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannels.locally', subChannelIds);
+
+  if (!client.cache) return;
+
+  const cached = subChannelIds
+    .map(channelId => pullFromCache<Amity.SubChannel>(['subChannel', 'get', channelId])!)
+    .filter(Boolean);
+
+  if (cached?.length < subChannelIds.length) return;
+
+  const subChannels = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  return {
+    data: subChannels,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/subChannelRepository/api/hardDeleteSubChannel.ts

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

package/src/subChannelRepository/api/index.ts

@@ -0,0 +1,7 @@
+export { getSubChannels as getSubChannelByIds } from './getSubChannels';
+
+export * from './createSubChannel';
+export * from './updateSubChannel';
+export * from './deleteSubChannel';
+export * from './hardDeleteSubChannel';
+export * from './softDeleteSubChannel';

package/src/subChannelRepository/api/markAsReadBySegment.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ *
+ * Mark subChannel as read by readToSegment
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to update
+ * @param readToSegment the segment to mark as read
+ * @returns a success boolean if the {@link Amity.SubChannel} was updated
+ *
+ * @category Channel API
+ * @async
+ */
+
+export const markAsReadBySegment = async ({
+  subChannelId,
+  readToSegment,
+}: {
+  subChannelId: Amity.SubChannel['subChannelId'];
+  readToSegment: number;
+}): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('subChannel/markAsReadBySegment', subChannelId);
+
+  try {
+    await client.http.put<Amity.MarkAsReadPayload>(
+      `/api/v1/markers/message-feeds/${subChannelId}/mark-read`,
+      { readToSegment },
+    );
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+};

package/src/subChannelRepository/api/querySubChannels.ts

@@ -0,0 +1,131 @@
+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 { inferIsDeleted } from '~/utils/inferIsDeleted';
+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>> & Amity.Pagination> => {
+  const client = getActiveClient();
+  client.log('channel/querySubChannels', query);
+
+  const {
+    page = { limit: 10 },
+    channelId,
+    includeDeleted,
+    pageToken,
+    ...params
+  } = convertQueryParams(query);
+
+  const response = await client.http.get<Amity.SubChannelPayload & Amity.Pagination>(
+    `/api/v5/message-feeds/channel/${channelId}`,
+    {
+      params: {
+        ...params,
+        isDeleted: inferIsDeleted(includeDeleted),
+        options: {
+          token: pageToken || toToken(page, 'afterbefore'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = response.data;
+  const data = await prepareSubChannelPayload(payload);
+  const subChannels = data.messageFeeds;
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data as Amity.ProcessedSubChannelPayload, { 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,
+    paging,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```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> & Amity.Pagination> | 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, paging: data?.paging }
+    : undefined;
+};

package/src/subChannelRepository/api/readingAPI.ts

@@ -0,0 +1,52 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
+
+/**
+ * ```js
+ * import { SubChannel } from '@amityco/ts-sdk'
+ * 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: userEntityMarkersPayload,
+    userFeedMarkers: userFeedMarkersPayload,
+    feedMarkers,
+    userMarkers,
+  } = payload;
+
+  const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+  const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache)
+    ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { 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'
+ * 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,51 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { convertChannelMarkerResponse, convertSubChannelMarkerResponse } from '~/utils/marker';
+
+/**
+ * ```js
+ * import { SubChannel } from '@amityco/ts-sdk'
+ * 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: userEntityMarkersPayload,
+    userFeedMarkers: userFeedMarkersPayload,
+    feedMarkers,
+    userMarkers,
+  } = payload;
+
+  const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+  const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache)
+    ingestInCache({ userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers }, { cachedAt });
+
+  fireEvent('local.feedMarker.fetched', { feedMarkers });
+  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return true;
+};