@amityco/ts-sdk 0.0.1-beta.1 → 0.0.1-beta.13

package/src/channel/api/removeChannelMembersRole.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { removeChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await removeChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Removes an {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param roleId The ID of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const removeChannelMembersRole = async (
+  channelId: Amity.Channel['channelId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][]
+): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('channel/removeChannelMembersRole', channelId, roleId, userIds)
+
+  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
+    { data: { channelId, role: roleId, userIds } }
+  )
+
+  if (client.cache) ingestInCache(data)
+
+  const { channelUsers } = data
+  return !!channelUsers.find(
+    channelUser =>
+      channelUser.channelId === channelId && !channelUser.roles.includes(roleId)
+  )
+}

package/src/channel/api/updateChannel.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { updateChannel } from '@amityco/ts-sdk'
+ * const updated = await updateChannel(channelId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const updateChannel = async (
+  channelId: Amity.Channel['channelId'],
+  patch: Patch<Amity.Channel, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+): Promise<Amity.Cached<Amity.Channel>> => {
+  const client = getActiveClient()
+  client.log('channel/updateChannel', channelId, patch)
+
+  const { data } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}`, patch,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+
+  const { channels } = data
+
+  return {
+    data: channels.find(channel => channel.channelId === channelId)!,
+    cachedAt,
+  }
+}

package/src/channel/events/index.ts

@@ -0,0 +1,6 @@
+export * from './onChannelUpdated'
+export * from './onChannelDeleted'
+export * from './onChannelJoined'
+export * from './onChannelLeft'
+export * from './onMemberAdded'
+export * from './onMemberRemoved'

package/src/channel/events/onChannelCreated.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { onChannelCreated } from '@amityco/ts-sdk'
+ * const dispose = onChannelCreated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelCreated = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelCreated',
+    'v3.channel.didCreate',
+    filter
+  )
+}

package/src/channel/events/onChannelDeleted.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { onChannelDeleted } from '@amityco/ts-sdk'
+ * const dispose = onChannelDeleted(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelDeleted = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelDeleted',
+    'v3.channel.didDelete',
+    filter
+  )
+}

package/src/channel/events/onChannelJoined.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { onChannelJoined } from '@amityco/ts-sdk'
+ * const dispose = onChannelJoined(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} was joined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelJoined = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelJoined',
+    'v3.channel.didJoin',
+    filter
+  )
+}

package/src/channel/events/onChannelLeft.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { onChannelLeft } from '@amityco/ts-sdk'
+ * const dispose = onChannelLeft(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} was left
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelLeft = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onChannelLeft',
+    'v3.channel.didLeave',
+    filter
+  )
+}

package/src/channel/events/onChannelUpdated.ts

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

package/src/channel/events/onMemberAdded.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { onMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onMemberAdded(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onMemberAdded = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onMemberAdded',
+    'v3.channel.didAddUsers',
+    filter
+  )
+}

package/src/channel/events/onMemberRemoved.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+import { createEventSubscriber } from '~/core/events'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { onMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onMemberRemoved(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onMemberRemoved = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    ingestInCache(payload)
+    callback(payload.channels[0])
+  }
+
+  return createEventSubscriber(
+    client,
+    'onMemberRemoved',
+    'v3.channel.didRemoveUsers',
+    filter
+  )
+}

package/src/channel/observers/index.ts

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

package/src/channel/observers/observeChannel.ts

@@ -0,0 +1,86 @@
+import { createQuery, runQuery } from '~/core/query/query'
+
+import { getActiveClient } from '~/client/api'
+
+import { getChannel } from '../api'
+
+import {
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onMemberAdded,
+  onMemberRemoved,
+} from '../events'
+
+/**
+ * ```js
+ * import { observeChannel } from '@amityco/ts-sdk'
+ *
+ * let channel = {}
+ * const dispose = observeChannel(channelId, ({ data }) => channel = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel 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 channel
+ *
+ * @category Channel Observer
+ */
+export const observeChannel = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onJoin',
+    'onLeft',
+    'onMemberAdded',
+    'onMemberRemoved'
+  ]
+>(
+  channelId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Channel>, Events>
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeChannel(tmpid: ${timestamp}) > listen`)
+
+  // wrapper function to make sure
+  const router = (
+    result: Amity.Snapshot<Amity.Channel>,
+    action: Events[number]
+  ) => {
+    // filter function
+    if (result.data?.channelId !== channelId) return
+
+    if (callback instanceof Function) return callback(result)
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
+    onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
+    onMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')),
+    onMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved'))
+  )
+
+  runQuery(
+    createQuery(getChannel, channelId),
+    result => result.data && router(result, 'onFetch')
+  )
+
+  return () => {
+    log(`observeChannel(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/client/api/activeClient.ts

@@ -0,0 +1,33 @@
+import { ASCError } from '~/core/errors'
+
+let activeClient: Amity.Client | null = null
+
+/**
+ * Get the active client
+ *
+ * @returns the active client instance
+ *
+ * @hidden
+ */
+export const getActiveClient = () => {
+  if (!activeClient) {
+    throw new ASCError(
+      'There is no active client',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.FATAL,
+    )
+  }
+
+  return activeClient!
+}
+
+/**
+ * Sets the active client
+ *
+ * @param client the client to assume as currently active client
+ *
+ * @hidden
+ */
+export const setActiveClient = (client: Amity.Client) => {
+  activeClient = client
+}

package/src/client/api/connectClient.ts

@@ -0,0 +1,73 @@
+import { disconnectClient } from '~/client/api/disconnectClient'
+import { getDeviceId } from '~/core/device'
+import { proxyMqttEvents, proxyWebsocketEvents } from '~/core/events'
+
+import { getActiveClient } from './activeClient'
+
+import { getToken } from './getToken'
+import { onClientBanned } from '../events'
+
+/**
+ * ```js
+ * import { connectClient } from '@amityco/ts-sdk/client/api'
+ * const success = await connectClient({
+ *   userId: 'XYZ123456789',
+ * })
+ * ```
+ *
+ * Connects an {@link Amity.Client} instance to ASC servers
+ *
+ * @param userId the user ID for the current session
+ * @param displayName the user's displayName for the current session
+ * @param deviceId Manual override of the user's device id (for device management)
+ * @param authToken The authentication token - necessary when network option is set to secure
+ * @returns a success boolean if connected
+ *
+ * @category Client API
+ * @async
+ */
+export const connectClient = async (params: {
+  userId: Amity.User['userId'],
+  displayName?: Amity.User['displayName'],
+  authToken?: string,
+  deviceId?: Amity.Device['deviceId'],
+}): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('client/api/connectClient', {apiKey: client.apiKey, ...params})
+
+  // default values
+  params.displayName ??= params.userId
+  params.deviceId ??= getDeviceId()
+
+  // @ts-ignore: in that particular case, typing can be
+  // ignored since we enforce default values just before.
+  const { accessToken, users } = await getToken(params)
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`
+
+  // manually setup the token for ws transport
+  client.ws.io.opts.query = {token: accessToken}
+
+  // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+  // wire websocket events to our event emitter
+  proxyWebsocketEvents(client.ws, client.emitter)
+
+  // TODO: in phase 2, this should not be necessary. we should have WS
+  // to be connected "on demand" rather than "by default"
+  await new Promise(resolve => {
+    client.ws.once('connect', resolve)
+    client.ws.open()
+  })
+
+  const unsubscribe = onClientBanned(() => {
+    disconnectClient()
+    unsubscribe()
+  })
+
+  client.userId = params.userId
+  client._internalUserId = users[0]._id
+  client.accessToken = accessToken
+
+  return client.ws.connected
+}

package/src/client/api/createClient.ts

@@ -0,0 +1,64 @@
+import { VERSION } from '~/version'
+
+import { createLogger } from '~/core/debug'
+
+import { API_ENDPOINT, getUrlFromTemplate, UrlTemplate } from '~/core/network'
+import { createHttpTransport, createMqttTransport, createWebsocketTransport } from '~/core/transports'
+
+import { createEventEmitter } from '~/core/events'
+
+import { getActiveClient, setActiveClient } from './activeClient'
+
+/**
+ * ```js
+ * import { createClient } from '@amityco/ts-sdk'
+ * const client = createClient(apiKey, 'https://asc.server/', 'myClient')
+ * ```
+ *
+ * Creates a new {@link Amity.Client} instance
+ *
+ * @param apiKey for the {@link Amity.Client} instance
+ * @param apiEndpoint endpoint to connect to
+ * @param debugSession session's identifier for the client's logger instance
+ * @returns A {@link Amity.Client} instance
+ *
+ * @category Client API
+ **/
+export const createClient = (
+  apiKey: string,
+  apiEndpoint: typeof API_ENDPOINT[keyof typeof API_ENDPOINT]|string = API_ENDPOINT.SG,
+  debugSession: string = 'amity'
+): Amity.Client => {
+  const log = createLogger(debugSession)
+
+  log('client/api/createClient', {
+    apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
+    apiEndpoint,
+  })
+
+  const http = createHttpTransport(getUrlFromTemplate(UrlTemplate.HTTP, apiEndpoint))
+  const ws = createWebsocketTransport(getUrlFromTemplate(UrlTemplate.HTTP, apiEndpoint))
+  const mqtt = createMqttTransport(getUrlFromTemplate(UrlTemplate.MQTT, apiEndpoint));
+
+  const emitter = createEventEmitter()
+
+  const client = {
+    version: `${VERSION}`,
+
+    apiKey,
+    log,
+    http,
+    ws,
+    mqtt,
+    emitter,
+    use: () => setActiveClient(client),
+  }
+
+  try {
+    getActiveClient()
+  } catch {
+    setActiveClient(client)
+  }
+
+  return client
+}

package/src/client/api/disconnectClient.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from './activeClient'
+
+/**
+ * ```js
+ * import { disconnectClient } from '@amityco/ts-sdk'
+ * const success = await disconnectClient()
+ * ```
+ *
+ * Disconnects an {@link Amity.Client} instance from ASC servers
+ *
+ * @param client The {@link Amity.Client} instance to disconnect
+ * @returns a success boolean if disconnected
+ *
+ * @category Client API
+ * @async
+ */
+export const disconnectClient = async (): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('client/api/disconnectClient')
+
+  await new Promise(resolve => {
+    client.ws.once('disconnect', resolve)
+    client.ws.disconnect()
+    client.mqtt.disconnect()
+  })
+
+  client.emitter.all.clear()
+  // FIXME: it removes listener in ws.ts, it breaks global ban event
+  client.ws.removeAllListeners()
+  client.mqtt.removeAllListeners()
+  client.userId = undefined
+  client.accessToken = undefined
+
+  return !client.ws.connected
+}

package/src/client/api/getToken.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from './activeClient'
+
+import { getDeviceInfo } from '~/core/device'
+
+/**
+ * Retrieves a pair of {@link Amity.Tokens} necessary for connection
+ *
+ * @param userId The userId to use to issue a token
+ * @param displayName The user's displayName
+ * @param deviceId The user's device Id (can be manually set for native users)
+ * @param authToken The authentication token - necessary when network option is set to secure
+ * @return The accessToken for the given userId
+ *
+ * @category Client API
+ * @hidden
+ */
+export const getToken = async (params: {
+  userId: Amity.User['userId'],
+  displayName: Amity.User['displayName'],
+  authToken?: string,
+  deviceId: Amity.Device['deviceId'],
+}) => {
+  const client = getActiveClient()
+  client.log('client/api/getToken', params)
+
+  const deviceInfo = await getDeviceInfo()
+
+  const { data } = await client.http.post<Amity.Tokens & { users: Amity.User[] }>('/v1/device', {
+    ...params, deviceInfo,
+  } , {
+    //@ts-ignore
+    headers: { 'X-API-Key': client.apiKey }
+  })
+
+  return data
+}

package/src/client/api/index.ts

@@ -0,0 +1,8 @@
+export { getActiveClient } from './activeClient'
+
+export * from './createClient'
+
+export * from './connectClient'
+export * from './disconnectClient'
+
+export * from './isConnected'