@amityco/ts-sdk 0.0.1-ec24ce0.0 → 0.0.1-ec76bde.0

package/src/stream/api/queryStreams.ts

@@ -1,8 +1,11 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: stream.query
+*/
 /**
  * ```js
  * import { queryStreams } from '@amityco/ts-sdk'
@@ -17,43 +20,45 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @category Stream API
  * @async
  */
-export const queryStreams = async (
-  query?: {
-    isLive?: boolean
-    statuses?: Amity.StreamStatus[]
-    userPublicIds?: Amity.User['userId'][]
-    sortBy?: 'lastCreated' | 'firstCreated'
-    isDeleted?: Amity.Stream['isDeleted']
-    page?: Amity.Page
-  }
-): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>> => {
-  const client = getActiveClient()
-  client.log('stream/queryStreams', query)
+export const queryStreams = async (query?: {
+  isLive?: boolean;
+  statuses?: Amity.StreamStatus[];
+  userPublicIds?: Amity.User['userId'][];
+  sortBy?: 'lastCreated' | 'firstCreated';
+  isDeleted?: Amity.Stream['isDeleted'];
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>> => {
+  const client = getActiveClient();
+  client.log('stream/queryStreams', query);
 
-  const { page, ...params } = query ?? {}
+  const { page, ...params } = query ?? {};
 
-  const { data } = await client.http.get<{results: Amity.StreamPayload} & Amity.Pagination>(
-    `/api/v3/video-streaming`, { params: {
-      ...params,
-      options: {
-        token: toToken(page, 'skiplimit'),
+  const { data } = await client.http.get<{ results: Amity.StreamPayload } & Amity.Pagination>(
+    `/api/v3/video-streaming`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
       },
-    } }
-  )
+    },
+  );
 
   // API-FIX: backend to response Amity.Response: const { paging, videoStreamings } = unwrapPayload(data)
   // API-FIX: seems returned data has a results identifier on top of data, like no other apis, and this is beautiful
-  const { paging, results: payload } = data
-  const { videoStreamings } = payload
+  const { paging, results: payload } = data;
+  const { videoStreamings } = payload;
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(payload as Amity.StreamPayload, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StreamPayload, { cachedAt });
 
-  const nextPage = toPage(paging.next)
-  const prevPage = toPage(paging.previous)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  return { data: videoStreamings, cachedAt, prevPage, nextPage }
-}
+  return { data: videoStreamings, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -68,11 +73,9 @@ export const queryStreams = async (
  *
  * @category Stream API
  */
- queryStreams.locally = (
-  query: Parameters<typeof queryStreams>[0],
-) => {
-  const client = getActiveClient()
-  client.log('stream/queryStreams.locally', query)
+queryStreams.locally = (query: Parameters<typeof queryStreams>[0]) => {
+  const client = getActiveClient();
+  client.log('stream/queryStreams.locally', query);
 
   // TODO
-}
+};

package/src/stream/api/tests/createStream.test.ts

@@ -0,0 +1,22 @@
+import { getActiveClient } from '~/client/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+import { createStream } from '../createStream';
+
+const bundle: Parameters<typeof createStream>[0] = {
+  title: 'my stream',
+  thumbnailFileId: streamResponse.data.videoStreamings[0].thumbnailFileId,
+};
+
+describe('createStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  it('creates a stream and returns the new stream', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(streamResponse);
+
+    const created = await createStream(bundle);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(`/api/v3/video-streaming`, bundle);
+    expect(created.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/stream/api/tests/deleteStream.test.ts

@@ -0,0 +1,50 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+
+import { deleteStream } from '~/stream/api';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+const resolvedDeleteValue = {
+  data: {
+    success: true,
+  },
+};
+
+jest.mock('~/stream/api/getStream', () => ({
+  getStream: jest.fn(() => Promise.resolve(streamResponse.data.videoStreamings[0])),
+}));
+
+describe('deleteStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('should return deleted stream', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    await expect(deleteStream(STREAM_ID)).resolves.toEqual(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteStream(STREAM_ID)).rejects.toThrow('error');
+  });
+
+  test('should update cache after deleted stream', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    pushToCache(['community', 'get', STREAM_ID], streamResponse.data.videoStreamings[0]);
+
+    await deleteStream(STREAM_ID);
+    const recieved = pullFromCache(['stream', 'get', STREAM_ID])?.data;
+
+    expect(recieved).toEqual(
+      expect.objectContaining({
+        isDeleted: true,
+      }),
+    );
+
+    disableCache();
+  });
+});

package/src/stream/api/tests/getStream.test.ts

@@ -0,0 +1,23 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+import { getStream } from '~/stream/api';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+describe('getStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the stream from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(streamResponse);
+    const { data } = await getStream(STREAM_ID);
+    expect(data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+
+  test('Should return stream from locally', () => {
+    const stream: ReturnType<typeof getStream.locally> = getStream.locally(STREAM_ID);
+
+    expect(stream?.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/stream/api/updateStream.ts

@@ -1,7 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: stream.update
+*/
 /**
  * ```js
  * import { updateStream } from '@amityco/ts-sdk'
@@ -19,23 +22,23 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  */
 export const updateStream = async (
   streamId: Amity.Stream['streamId'],
-  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>
+  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Stream>> => {
-  const client = getActiveClient()
-  client.log('stream/updateStream', streamId, patch)
+  const client = getActiveClient();
+  client.log('stream/updateStream', streamId, patch);
 
   const { data } = await client.http.put<Amity.StreamPayload>(
     `/api/v3/video-streaming/${streamId}`,
-    patch
-  )
+    patch,
+  );
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { videoStreamings } = data
+  const { videoStreamings } = data;
 
   return {
     data: videoStreamings.find(stream => stream.streamId === streamId)!,
     cachedAt,
-  }
-}
+  };
+};

package/src/stream/events/index.ts

@@ -1,3 +1,3 @@
-export { onStreamStarted } from './onStreamStarted'
-export { onStreamStopped } from './onStreamStopped'
-export { onStreamRecorded } from './onStreamRecorded'
+export { onStreamStarted } from './onStreamStarted';
+export { onStreamStopped } from './onStreamStopped';
+export { onStreamRecorded } from './onStreamRecorded';

package/src/stream/events/onStreamRecorded.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Stream Events
  */
-export const onStreamRecorded = (
-  callback: Amity.Listener<Amity.Stream>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onStreamRecorded = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {
-    ingestInCache(payload)
-    callback(payload.videoStreamings[0])
-  }
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
 
   return createEventSubscriber(
     client,
     'stream/onStreamRecorded',
     'video-streaming.didRecord',
     filter,
-  )
-}
+  );
+};

package/src/stream/events/onStreamStarted.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Stream Events
  */
-export const onStreamStarted = (
-  callback: Amity.Listener<Amity.Stream>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onStreamStarted = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {
-    ingestInCache(payload)
-    callback(payload.videoStreamings[0])
-  }
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
 
   return createEventSubscriber(
     client,
     'stream/onStreamStarted',
     'video-streaming.didStart',
     filter,
-  )
-}
+  );
+};

package/src/stream/events/onStreamStopped.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,13 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Stream Events
  */
-export const onStreamStopped = (
-  callback: Amity.Listener<Amity.Stream>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onStreamStopped = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.StreamPayload) => {
-    ingestInCache(payload)
-    callback(payload.videoStreamings[0])
-  }
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'stream/onStreamStarted',
-    'video-streaming.didStop',
-    filter,
-  )
-}
+  return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStop', filter);
+};

package/src/subChannel/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 = 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/subChannel/api/deleteSubChannel.ts

@@ -0,0 +1,57 @@
+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';
+
+/* begin_public_function
+  id: subchannel.soft_delete, subchannel.hard_delete
+*/
+/**
+ * ```js
+ * import { deleteSubChannel } from '@amityco/ts-sdk'
+ * const success = await deleteSubChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.SubChannel}
+ *
+ * @param subChannelId The {@link Amity.SubChannel} ID to delete
+ * @return A success boolean if the {@link Amity.SubChannel} was deleted
+ *
+ * @category Channel API
+ * @async
+ */
+export const deleteSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  permanent = false,
+): Promise<Amity.SubChannel> => {
+  const client = getActiveClient();
+  client.log('channel/deleteSubChannel', subChannelId);
+
+  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;
+};
+/* end_public_function */

package/src/subChannel/api/getSubChannel.ts

@@ -0,0 +1,89 @@
+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';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/* begin_public_function
+  id: subchannel.get
+*/
+/**
+ * ```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 = 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;
+  }
+};
+/* end_public_function */
+
+/**
+ * ```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/subChannel/api/getSubChannels.ts

@@ -0,0 +1,77 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+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 = 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/subChannel/api/index.ts

@@ -0,0 +1,8 @@
+export * from './querySubChannels';
+export * from './getSubChannels';
+export * from './getSubChannel';
+// export * from './getSubChannelByCreator';
+
+export * from './createSubChannel';
+export * from './updateSubChannel';
+export * from './deleteSubChannel';