@amityco/ts-sdk 0.0.1-003998f.0

package/src/role/api/getRole.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = await getRole('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ * @async
+ */
+export const getRole = async (roleId: Amity.Role['roleId']): Promise<Amity.Cached<Amity.Role>> => {
+  const client = getActiveClient();
+  client.log('role/getRole', roleId);
+
+  const { data } = await client.http.get<Amity.Role[]>(`/api/v3/roles/${roleId}`);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt });
+
+  return {
+    data: data.find(role => role.roleId === roleId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = getRole.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object from cache
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ */
+getRole.locally = (roleId: Amity.Role['roleId']): Amity.Cached<Amity.Role> | undefined => {
+  const client = getActiveClient();
+  client.log('role/getRole.locally', roleId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Role>(['role', 'get', roleId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/role/api/index.ts

@@ -0,0 +1,2 @@
+export { queryRoles } from './queryRoles';
+export { getRole } from './getRole';

package/src/role/api/queryRoles.ts

@@ -0,0 +1,74 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = await queryRoles()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ * @async
+ */
+export const queryRoles = async (query?: {
+  displayName?: Amity.Role['displayName'];
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Role>>> => {
+  const client = getActiveClient();
+  client.log('role/queryRoles', query);
+
+  const { page = { limit: 10 }, displayName, sortBy, ...params } = query ?? {};
+
+  // API-FIX: parameters should be querystring.
+  const { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(`/api/v3/roles`, {
+    params: {
+      ...params,
+      keyword: displayName,
+      sortBy,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  });
+
+  const { paging, ...payload } = data;
+  const { roles } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.RolePayload, { cachedAt });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: roles, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = queryRoles.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ */
+queryRoles.locally = (query: Parameters<typeof queryRoles>[0]) => {
+  const client = getActiveClient();
+  client.log('role/queryRoles.locally', query);
+
+  // TODO
+};

package/src/stream/api/createStream.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createStream } from '@amityco/ts-sdk'
+ * const created = await createStream({ title: 'my stream', 'thumbnailFileId': fileId  })
+ * ```
+ *
+ * Creates an {@link Amity.Stream}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Stream}
+ * @returns The newly created {@link Amity.Stream}
+ *
+ * @category Stream API
+ * @async
+ */
+export const createStream = async (
+  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean },
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/createStream', bundle);
+
+  const { data } = await client.http.post<Amity.StreamPayload>('/api/v3/video-streaming', bundle);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings[0],
+    cachedAt,
+  };
+};

package/src/stream/api/deleteStream.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache } from '~/cache/api';
+
+import { getStream } from './getStream';
+
+// import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```js
+ * import { deleteStream } from '@amityco/ts-sdk'
+ * const success = await deleteStream(streamId)
+ * ```
+ *
+ * Deletes a {@link Amity.Stream}
+ *
+ * @param streamId The {@link Amity.Stream} ID to delete
+ * @return A success boolean if the {@link Amity.Stream} was deleted
+ *
+ * @category Stream API
+ * @async
+ */
+export const deleteStream = async (streamId: Amity.Stream['streamId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('stream/deleteStream', streamId);
+
+  const stream = await getStream(streamId);
+
+  // API-FIX: it returns { success: boolean } but seems it should be Amity.Response<{ success: boolean }
+  // API-FIX: swagger docs are wrong!
+  const { data } = await client.http.delete<{ success: boolean }>(
+    `/api/v3/video-streaming/${streamId}`,
+  );
+
+  const { success } = data; // unwrapPayload(data)
+  const deleted = { ...stream.data, isDeleted: true };
+
+  upsertInCache(['stream', 'get', streamId], deleted);
+
+  return success;
+};

package/src/stream/api/disposeStream.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { disposeStream } from '@amityco/ts-sdk'
+ * const stream = await disposeStream(streamId)
+ * ```
+ *
+ * Dispose a {@link Amity.Stream}.
+ * Streaming status will be updated to "ended" and streaming url will be invalidated
+ *
+ * @param streamId The {@link Amity.Stream} ID to dispose
+ * @returns the associated {@link Amity.Stream} object
+ *
+ * @category Stream API
+ * @async
+ */
+export const disposeStream = async (
+  streamId: Amity.Stream['streamId'],
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/disposeStream', streamId);
+
+  const { data } = await client.http.delete<Amity.StreamPayload>(
+    `/api/v3/video-streaming/${streamId}/streaming-url`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings.find(stream => stream.streamId === streamId)!,
+    cachedAt,
+  };
+};

package/src/stream/api/getStream.ts

@@ -0,0 +1,70 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getStream } from '@amityco/ts-sdk'
+ * const stream = await getStream('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Stream} object
+ *
+ * @param streamId the ID of the {@link Amity.Stream} to fetch
+ * @returns the associated {@link Amity.Stream} object
+ *
+ * @category Stream API
+ * @async
+ */
+export const getStream = async (
+  streamId: Amity.Stream['streamId'],
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/getStream', streamId);
+
+  const { data } = await client.http.get<Amity.StreamPayload>(
+    `/api/v3/video-streaming/${streamId}`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings.find(stream => stream.streamId === streamId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getStream } from '@amityco/ts-sdk'
+ * const stream = getStream.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Stream} object
+ *
+ * @param streamId the ID of the {@link Amity.Stream} to fetch
+ * @returns the associated {@link Amity.Stream} object
+ *
+ * @category Stream API
+ */
+getStream.locally = (
+  streamId: Amity.Stream['streamId'],
+): Amity.Cached<Amity.Stream> | undefined => {
+  const client = getActiveClient();
+  client.log('stream/getStream', streamId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/stream/api/index.ts

@@ -0,0 +1,8 @@
+export * from './getStream';
+// export * from './getStreams' // API-FIX: missing from api
+export * from './queryStreams';
+
+export * from './createStream';
+export * from './updateStream';
+export * from './deleteStream';
+export * from './disposeStream';

package/src/stream/api/queryStreams.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryStreams } from '@amityco/ts-sdk'
+ * const streams = await queryStreams()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Stream} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Stream} objects
+ *
+ * @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);
+
+  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'),
+        },
+      },
+    },
+  );
+
+  // 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 cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StreamPayload, { cachedAt });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: videoStreamings, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryStreams } from '@amityco/ts-sdk'
+ * const streams = queryStreams.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Stream} objects from cache
+ *
+ * @param query The query parameters
+ * @returns streams
+ *
+ * @category Stream API
+ */
+queryStreams.locally = (query: Parameters<typeof queryStreams>[0]) => {
+  const client = getActiveClient();
+  client.log('stream/queryStreams.locally', query);
+
+  // TODO
+};

package/src/stream/api/updateStream.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { updateStream } from '@amityco/ts-sdk'
+ * const updated = await updateStream(streamId, { title: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Stream}
+ *
+ * @param streamId The ID of the {@link Amity.Stream} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Stream} object
+ *
+ * @category Stream API
+ * @async
+ */
+export const updateStream = async (
+  streamId: Amity.Stream['streamId'],
+  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>,
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/updateStream', streamId, patch);
+
+  const { data } = await client.http.put<Amity.StreamPayload>(
+    `/api/v3/video-streaming/${streamId}`,
+    patch,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings.find(stream => stream.streamId === streamId)!,
+    cachedAt,
+  };
+};

package/src/stream/events/index.ts

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

package/src/stream/events/onStreamRecorded.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamRecorded } from '@amityco/ts-sdk'
+ * const dispose = onStreamRecorded(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when the recordings of a {@link Amity.Stream} are available
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamRecorded = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamRecorded',
+    'video-streaming.didRecord',
+    filter,
+  );
+};

package/src/stream/events/onStreamStarted.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamStarted } from '@amityco/ts-sdk'
+ * const dispose = onStreamStarted(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Stream} has started airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamStarted = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamStarted',
+    'video-streaming.didStart',
+    filter,
+  );
+};

package/src/stream/events/onStreamStopped.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onStreamStopped } from '@amityco/ts-sdk'
+ * const dispose = onStreamStopped(stream => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Stream} has stopped airing
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Stream Events
+ */
+export const onStreamStopped = (callback: Amity.Listener<Amity.Stream>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.StreamPayload) => {
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
+
+  return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStop', filter);
+};

package/src/user/api/getUser.ts

@@ -0,0 +1,85 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = await getUser('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+export const getUser = async (
+  userId: Amity.User['userId'],
+  isLive = false,
+): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/getUser', userId);
+
+  if (!isLive) {
+    console.log('getUser will be deprecated on 25th November 2022, please use liveUser instead.');
+  }
+
+  isInTombstone('user', userId);
+
+  let data: Amity.UserPayload;
+
+  try {
+    const response = await client.http.get<Amity.UserPayload>(
+      `/api/v3/users/${encodeURIComponent(userId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('user', userId);
+    }
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { users } = data;
+
+  fireEvent('user.fetched', data);
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = getUser.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object from cache
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ */
+getUser.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.User> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getUser.locally', userId);
+
+  return client.cache && pullFromCache<Amity.User>(['user', 'get', userId]);
+};