@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-c58e50d.0

package/src/stream/api/updateStream.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api'
+
+import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```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
+ *
+ * @stream 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)
+
+  const { data } = await client.http.put<Amity.Response<Amity.StreamPayload>>(
+    `/api/v3/video-streaming/${streamId}`,
+    patch
+  )
+
+  // TODO:
+
+  const { videoStreamings } = unwrapPayload(data)
+  return videoStreamings.find(stream => stream.streamId === streamId)!
+}

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,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```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) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.videoStreamings[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamRecorded',
+    'video-streaming.didRecord',
+    filter,
+  )
+}

package/src/stream/events/onStreamStarted.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```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) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.videoStreamings[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamStarted',
+    'video-streaming.didStart',
+    filter,
+  )
+}

package/src/stream/events/onStreamStopped.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```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) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.videoStreamings[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'stream/onStreamStarted',
+    'video-streaming.didStop',
+    filter,
+  )
+}

package/src/user/api/getUser.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { decoratePayload } from '~/core/query'
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const 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'],
+) => {
+  const client = getActiveClient()
+  client.log('user/getUser', userId)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.UserPayload>(
+    `/api/v3/users/${userId}`,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { users } = data
+  return users.find(user => user.userId === userId)!
+}
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const 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'],
+) => {
+  const client = getActiveClient()
+  client.log('user/getUser.locally', userId)
+
+  const [user] = pullFromCache('user', userId) ?? []
+  return user
+}

package/src/user/api/getUsers.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const users = await getUsers(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+export const getUsers = async (
+  userIds: Amity.User['userId'][],
+) => {
+  const client = getActiveClient()
+  client.log('user/getUsers', userIds)
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.UserPayload>(
+    `/api/v3/users/list`,
+    { params: { userIds } },
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+
+  const { users } = data
+  return toRecord(users)
+}
+
+/**
+ * ```js
+ * import { getUsers } from '@amityco/ts-sdk'
+ * const users = getUsers.locally!(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.User} objects from cache
+ *
+ * @param userIds the IDs of the {@link Amity.User} to fetch
+ * @returns the associated collection of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+getUsers.locally = (
+  userIds: Amity.User['userId'][],
+) => {
+  const cached = pullFromCache('user', ...userIds) ?? []
+
+  if (cached?.length === userIds.length)
+    return toRecord(cached)
+}

package/src/user/api/index.ts

@@ -0,0 +1,5 @@
+export { getUser } from './getUser'
+export { getUsers } from './getUsers'
+export { queryUsers } from './queryUsers'
+
+export { updateUser } from './updateUser'

package/src/user/api/queryUsers.ts

@@ -0,0 +1,88 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload, toPage, toToken } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { users, previous, next } = await queryUsers({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ * @async
+ */
+export const queryUsers = async (
+  query?: {
+    displayName?: Amity.User['displayName']
+    filter?: 'all' | 'flagged'
+    sortBy?: 'displayName' | 'firstCreated' | 'lastCreated'
+    page?: Amity.Page
+  }
+) => {
+  const client = getActiveClient()
+  client.log('user/queryUsers', query)
+
+  const {
+    page,
+    displayName,
+    filter = 'all',
+    sortBy = 'displayName',
+    ...params
+  } = query ?? {}
+
+  // API-FIX: parameters should be querystring.
+  const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(
+    `/api/v3/users`, { params: {
+      ...params,
+      keyword: displayName,
+      filter,
+      sortBy,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      }
+    } }
+  )
+
+  // unpacking
+  const { paging, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, any[]>)
+  ingestInCache(response as unknown as Record<string, any[]>)
+
+  const prevPage = toPage(paging.previous)
+  const nextPage = toPage(paging.next)
+
+  const { users } = response
+  return { data: toRecord(users), prevPage, nextPage }
+}
+
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const users = queryUsers.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.User} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category User API
+ */
+queryUsers.locally = (
+  query: Parameters<typeof queryUsers>[0],
+) => {
+  const client = getActiveClient()
+  client.log('user/queryUsers.locally', query)
+
+  // TODO
+}

package/src/user/api/updateUser.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { updateUser } from '@amityco/ts-sdk'
+ * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.User}
+ *
+ * @param userId The ID of the {@link Amity.User} to update
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+export const updateUser = async (
+  userId: Amity.User['userId'],
+  patch: Patch<Amity.User, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+) => {
+  const client = getActiveClient()
+  client.log('user/updateUser', userId, patch)
+
+  // API-FIX: Endpoint is malformed, userId should be a url param.
+  /*
+    const { data } = await client.http.put<Amity.Response<UserPayload>>(
+      `/api/v3/users/${userId}`, patch,
+    )
+  */
+
+  const { data } = await client.http.put<Amity.UserPayload>(
+    `/api/v3/users/`, { userId, ...patch, createNewUserWhenNotFound: false },
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  // no need for event, fired by server
+
+  return data.users.find(user => user.userId === userId)!
+}

package/src/user/events/index.ts

@@ -0,0 +1 @@
+export * from './onUserUpdated'

package/src/user/events/onUserUpdated.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```js
+ * import { onUserUpdated } from '@amityco/ts-sdk'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} have been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserUpdated = (
+  callback: Amity.Listener<Amity.User>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.UserPayload) => {
+    decoratePayload(payload)
+    ingestInCache(payload)
+    callback(payload.users[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'user/onUserUpdate',
+    'v3.user.didUpdate',
+    filter
+  )
+}

package/src/user/observers/index.ts

@@ -0,0 +1 @@
+export { observeUser } from './observeUser'

package/src/user/observers/observeUser.ts

@@ -0,0 +1,64 @@
+import { createQuery, runQuery } from '~/core/query/query'
+
+import { getActiveClient } from '~/client/api'
+
+import { getUser } from '../api'
+import { onUserUpdated } from '../events'
+
+/**
+ * ```js
+ * import { observeUser } from '@amityco/ts-sdk'
+ *
+ * let user = {}
+ * const dispose = observeUser(userId, updated => user = updated)
+ * ```
+ *
+ * @param userId the ID of the user 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 user
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ * @category User Observer
+ */
+export const observeUser = <Events extends ['onFetch', 'onUpdate']>(
+  userId: string,
+  callback: Amity.ObjectListener<Amity.QueryResult<Amity.User>, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeUser(tmpid: ${timestamp}) > listen`)
+
+  // wrapper function to make sure
+  const router = (
+    result: Amity.QueryResult<Amity.User>,
+    action: Events[number]
+  ) => {
+    // filter function
+    if (result.data?.userId !== userId) return
+
+    if (callback instanceof Function)
+      return callback(result)
+
+    if (action !== 'onFetch')
+      callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onUserUpdated(data => router({ data }, 'onUpdate'))
+  )
+
+  runQuery(
+    createQuery(getUser, userId),
+    (result) => result.data && router(result, 'onFetch'),
+  )
+
+  return () => {
+    log(`observeUser(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.json",
+
+  "include": ["./src"],
+  "exclude": ["node_modules"],
+
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "paths": {
+      "~/*": ["./*"],
+    },
+
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "declarationDir": "./dist",
+    "noEmit": true, // by rollup
+
+    "module": "es2020",
+    "target": "es2017",
+
+    "lib": [
+      "esnext",
+      "es7",
+      "es6",
+      "dom",
+    ],
+  }
+}

package/@types/core/cache.d.ts

@@ -1,21 +0,0 @@
-export {};
-declare global {
-    namespace Amity {
-        /**
-         * The typing of cache allows to distribute the typings properly for each values
-         * of T, so that there will be a proper auto-completion for K = "user" or K = "file"
-         * @hidden
-         */
-        type Cache = {
-            lookup: Record<string, string>;
-        } & {
-            [K in keyof Amity.Model]?: Amity.Store<Amity.Model[K]>;
-        };
-        /**
-         * Possible stores should be restricted to the one to fit in cache
-         * @hidden
-         */
-        type Domain = keyof Amity.Model;
-    }
-}
-//# sourceMappingURL=cache.d.ts.map

package/@types/core/cache.js

@@ -1 +0,0 @@
-export {};

package/@types/core/errors.d.ts

@@ -1,32 +0,0 @@
-export {};
-declare global {
-    namespace Amity {
-        const enum ErrorLevel {
-            ERROR = "error",
-            FATAL = "fatal"
-        }
-        const enum ServerError {
-            BAD_REQUEST = 400000,
-            UNAUTHORIZED = 400100,
-            PERMISSION_DENIED = 400301,
-            ITEM_NOT_FOUND = 400400,
-            CONFLICT = 400900,
-            FORBIDDEN = 400300,
-            USER_IS_MUTED = 400302,
-            USER_IS_BANNED = 400304,
-            CHANNEL_IS_MUTED = 400303,
-            NUMBER_OF_MEMBERS_EXCEEDED = 400305,
-            MAX_REPETITION_EXCEEDED = 400307,
-            BAN_WORD_FOUND = 400308,
-            LINK_NOT_ALLOWED = 400309,
-            BUSINESS_ERROR = 500000
-        }
-        const enum ClientError {
-            UNKNOWN_ERROR = 800000,
-            INVALID_PARAMETERS = 800110,
-            QUERY_IN_PROGRESS = 800170,
-            CONNECTION_ERROR = 800210
-        }
-    }
-}
-//# sourceMappingURL=errors.d.ts.map

package/@types/core/errors.js

@@ -1 +0,0 @@
-export {};

package/@types/core/events.d.ts

@@ -1,46 +0,0 @@
-export {};
-declare global {
-    namespace Amity {
-        type Listener<T = any> = (params: T) => void;
-        type ObjectListener<T, K extends string[]> = Listener<T> | ({
-            onEvent?: (event: K[number], params: T) => void;
-        } & {
-            [P in K[number]]?: Listener<T>;
-        });
-        type Unsubscriber = () => void;
-        type Subscriber<T = any> = (fn: Amity.Listener<T>) => Unsubscriber;
-        type Events = {
-            disconnected: string | undefined;
-            'v3.user.didUpdate': Amity.UserPayload;
-            'v3.channel.didCreate': Amity.ChannelPayload;
-            'v3.channel.didUpdate': Amity.ChannelPayload;
-            'v3.channel.didDelete': Amity.ChannelPayload;
-            'v3.channel.didJoin': Amity.ChannelPayload;
-            'v3.channel.didLeave': Amity.ChannelPayload;
-            'v3.channel.didAddUsers': Amity.ChannelPayload;
-            'v3.channel.didRemoveUsers': Amity.ChannelPayload;
-            'v3.channel.didBan': Amity.ChannelPayload;
-            'v3.channel.didUnban': Amity.ChannelPayload;
-            'v3.message.didCreate': Amity.MessagePayload;
-            'v3.message.didUpdate': Amity.MessagePayload;
-            'v3.message.didDelete': Amity.MessagePayload;
-            'video-streaming.didRecord': Amity.StreamPayload;
-            'video-streaming.didStart': Amity.StreamPayload;
-            'video-streaming.didStop': Amity.StreamPayload;
-            'v3.community.didCreate': Amity.CommunityPayload;
-            'v3.community.didUpdate': Amity.CommunityPayload;
-            'v3.community.didDelete': Amity.CommunityPayload;
-            'v3.community.didJoin': Amity.CommunityPayload;
-            'v3.community.didLeave': Amity.CommunityPayload;
-            'v3.community.didAddUsers': Amity.CommunityPayload;
-            'v3.community.didRemoveUsers': Amity.CommunityPayload;
-            'v3.post.didCreate': Amity.PostPayload;
-            'v3.post.didUpdate': Amity.PostPayload;
-            'v3.post.didDelete': Amity.PostPayload;
-            'v3.comment.didCreate': Amity.CommentPayload;
-            'v3.comment.didUpdate': Amity.CommentPayload;
-            'v3.comment.didDelete': Amity.CommentPayload;
-        };
-    }
-}
-//# sourceMappingURL=events.d.ts.map

package/@types/core/events.js

@@ -1 +0,0 @@
-export {};