@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.30

package/src/report/api/index.ts

@@ -1,4 +1,4 @@
-export * from './createReport'
-export * from './deleteReport'
+export * from './createReport';
+export * from './deleteReport';
 
-export * from './isReportedByMe'
+export * from './isReportedByMe';

package/src/report/api/isReportedByMe.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { synchronousWSCall } from '~/core/transports'
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
 
-import REFERENCE_TYPES from '../constants/referenceTypes'
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
  * ```js
@@ -15,23 +15,23 @@ import REFERENCE_TYPES from '../constants/referenceTypes'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const isReportedByMe = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
+  referenceId: string,
 ) => {
-  const client = getActiveClient()
-  client.log('report/isReportedByMe', { referenceType, referenceId })
+  const client = getActiveClient();
+  client.log('report/isReportedByMe', { referenceType, referenceId });
 
-  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType]
+  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
 
   const { result, isFlagByMe } =
     (await synchronousWSCall<{
-      result?: boolean
-      isFlagByMe?: boolean
+      result?: boolean;
+      isFlagByMe?: boolean;
     }>(client, eventName, {
       [primaryKey]: referenceId,
-    })) ?? {}
+    })) ?? {};
 
-  return result ?? isFlagByMe ?? false
-}
+  return result ?? isFlagByMe ?? false;
+};

package/src/report/constants/referenceTypes.ts

@@ -19,4 +19,4 @@ export default {
     eventName: 'user.isFlagByMe',
     primaryKey: 'userId',
   },
-}
+};

package/src/role/api/getRole.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decorateModels } from '~/core/query'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -17,19 +17,20 @@ import { decorateModels } from '~/core/query'
  * @category Role API
  * @async
  */
-export const getRole = async (roleId: Amity.Role['roleId']) => {
-  const client = getActiveClient()
-  client.log('role/getRole', roleId)
+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 { data } = await client.http.get<Amity.Role[]>(`/api/v3/roles/${roleId}`);
 
-  decorateModels(data)
-  ingestInCache({ roles: data })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt });
 
-  return data.find(role => role.roleId === roleId)!
-}
+  return {
+    data: data.find(role => role.roleId === roleId)!,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
@@ -44,10 +45,18 @@ export const getRole = async (roleId: Amity.Role['roleId']) => {
  *
  * @category Role API
  */
-getRole.locally = (roleId: Amity.Role['roleId']) => {
-  const client = getActiveClient()
-  client.log('role/getRole.locally', roleId)
+getRole.locally = (roleId: Amity.Role['roleId']): Amity.Cached<Amity.Role> | undefined => {
+  const client = getActiveClient();
+  client.log('role/getRole.locally', roleId);
 
-  const [role] = pullFromCache('role', roleId) ?? []
-  return role
-}
+  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

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

package/src/role/api/queryRoles.ts

@@ -1,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -20,42 +19,38 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const queryRoles = async (query?: {
-  displayName?: Amity.Role['displayName']
-  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated'
-  page?: Amity.Page
-}) => {
-  const client = getActiveClient()
-  client.log('role/queryRoles', 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, displayName, sortBy, ...params } = 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 { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(`/api/v3/roles`, {
+    params: {
+      ...params,
+      keyword: displayName,
+      sortBy,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
-    }
-  )
+    },
+  });
 
-  // unpacking
-  const { paging, ...response } = data
+  const { paging, ...payload } = data;
+  const { roles } = payload;
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.RolePayload, { cachedAt });
 
-  const prevPage = toPage(paging.previous)
-  const nextPage = toPage(paging.next)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  const { roles } = response
-  return { data: toRecord(roles), prevPage, nextPage }
-}
+  return { data: roles, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -72,8 +67,8 @@ export const queryRoles = async (query?: {
  * @category Role API
  */
 queryRoles.locally = (query: Parameters<typeof queryRoles>[0]) => {
-  const client = getActiveClient()
-  client.log('role/queryRoles.locally', query)
+  const client = getActiveClient();
+  client.log('role/queryRoles.locally', query);
 
   // TODO
-}
+};

package/src/stream/api/createStream.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { unwrapPayload } from '~/core/transports'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -17,17 +17,20 @@ import { unwrapPayload } from '~/core/transports'
  * @async
  */
 export const createStream = async (
-  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean }
-) => {
-  const client = getActiveClient()
-  client.log('stream/createStream', bundle)
+  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.Response<Amity.StreamPayload>>(
-    '/api/v3/video-streaming/', bundle,
-  )
+  const { data } = await client.http.post<Amity.StreamPayload>('/api/v3/video-streaming', bundle);
 
-  // TODO:
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { videoStreamings } = unwrapPayload(data)
-  return videoStreamings[0]!
-}
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings[0],
+    cachedAt,
+  };
+};

package/src/stream/api/deleteStream.ts

@@ -1,8 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { getStream } from './getStream'
+import { upsertInCache } from '~/cache/api';
 
-import { unwrapPayload } from '~/core/transports'
+import { getStream } from './getStream';
+
+// import { unwrapPayload } from '~/core/transports'
 
 /**
  * ```js
@@ -18,21 +20,22 @@ import { unwrapPayload } from '~/core/transports'
  * @category Stream API
  * @async
  */
-export const deleteStream = async (
-  streamId: Amity.Stream['streamId'],
-) => {
-  const client = getActiveClient()
-  client.log('stream/deleteStream', streamId)
+export const deleteStream = async (streamId: Amity.Stream['streamId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('stream/deleteStream', streamId);
 
-  const { data } = await client.http.delete<Amity.Response<{ success: boolean }>>(
-    `/api/v3/video-streaming/${streamId}`
-  )
+  const stream = await getStream(streamId);
 
-  // TODO:
+  // 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 } = unwrapPayload(data)
+  const { success } = data; // unwrapPayload(data)
+  const deleted = { ...stream.data, isDeleted: true };
 
-  const deleted = await getStream(streamId)
+  upsertInCache(['stream', 'get', streamId], deleted);
 
-  return 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

@@ -1,29 +1,70 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { unwrapPayload } from '~/core/transports'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { getStream } from '@amityco/ts-sdk'
- * const stream = await getStream(streamId)
+ * 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'],
-) => {
-  const client = getActiveClient()
-  client.log('stream/getStream', 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 { data } = await client.http.get<Amity.Response<Amity.StreamPayload>>(
-    `/api/v3/video-streaming/${streamId}`
-  )
+  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
 
-  // TODO:
+  if (!cached) return;
 
-  const { videoStreamings } = unwrapPayload(data)
-  return videoStreamings.find(stream => stream.streamId === streamId)!
-}
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/stream/api/index.ts

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

package/src/stream/api/queryStreams.ts

@@ -1,11 +1,12 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { unwrapPayload } from '~/core/transports'
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { queryStreams } from '@amityco/ts-sdk'
- * const streams = await queryStreams(query)
+ * const streams = await queryStreams()
  * ```
  *
  * Queries a paginable list of {@link Amity.Stream} objects
@@ -16,29 +17,61 @@ import { unwrapPayload } from '~/core/transports'
  * @category Stream API
  * @async
  */
-export const queryStreams = async (
-  query?: {
-    isLive?: boolean
-    statuses?: Amity.StreamStatus[]
-    userPublicIds?: Amity.User['userId'][]
-    sortBy: 'lastCreated'
-    isDeleted?: Amity.Stream['isDeleted']
-    page?: Amity.Page
-  }
-) => {
-  const client = getActiveClient()
-  client.log('stream/queryStreams', query)
-
-  const { page, ...params } = query ?? {}
-
-  const { data } = await client.http.get<
-    Amity.Response<Amity.StreamPayload & Amity.Pagination>
-  >(`/api/v3/video-streaming`, { params })
-
-  // TODO:
-
-  // unpacking
-  const { videoStreamings: streams, paging } = unwrapPayload(data)
-
-  return streams
-}
+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

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { unwrapPayload } from '~/core/transports'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -14,23 +14,28 @@ import { unwrapPayload } from '~/core/transports'
  * @param patch The patch data to apply
  * @returns the updated {@link Amity.Stream} object
  *
- * @stream Stream API
+ * @category Stream API
  * @async
  */
 export const updateStream = async (
   streamId: Amity.Stream['streamId'],
-  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>
-) => {
-  const client = getActiveClient()
-  client.log('updateStream', streamId, patch)
+  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.Response<Amity.StreamPayload>>(
+  const { data } = await client.http.put<Amity.StreamPayload>(
     `/api/v3/video-streaming/${streamId}`,
-    patch
-  )
+    patch,
+  );
 
-  // TODO:
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { videoStreamings } = unwrapPayload(data)
-  return videoStreamings.find(stream => stream.streamId === streamId)!
-}
+  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,8 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -19,21 +18,18 @@ import { ingestInCache } from '~/core/cache'
  *
  * @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) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.videoStreamings[0])
-  }
+    ingestInCache(payload);
+    callback(payload.videoStreamings[0]);
+  };
 
   return createEventSubscriber(
     client,
     'stream/onStreamRecorded',
     'video-streaming.didRecord',
     filter,
-  )
-}
+  );
+};