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

package/src/core/transports/mqtt.ts

@@ -0,0 +1,141 @@
+import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from 'mqtt/dist/mqtt'
+import { ASCError, ASCUnknownError } from '~/core/errors'
+
+const QOS_FAILURE_CODE = 128
+
+const RETRY_BASE_TIMEOUT = 1000;
+const RETRY_COUNT_MAX = 10;
+
+const enum MqttError {
+  IDENTIFIER_REJECTED = 2,
+  BAD_USERNAME_OR_PASSWORD = 4,
+  NOT_AUTHORIZED = 5,
+}
+
+export function getMqttOptions(params: { username: string, password: string, clientId?: string }): IClientOptions {
+  return {
+    clean: false, // keep subscriptions
+    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
+    protocolId: 'MQTT',
+    protocolVersion: 4,
+    reconnectPeriod: 0, // disable auto reconnect
+    will: {
+      topic: 'WillMsg',
+      payload: 'Connection Closed abnormally..!',
+      qos: 0,
+      retain: false
+    },
+
+    ...params
+  }
+}
+
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The mqtt server's URL
+ * @returns A pre-configured (non-connected) mqtt client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
+  let mqttClient: MqttClient | void;
+  let retryCount = 0
+  let allowReconnection = true
+
+  async function connect(params: { accessToken: string, userId: string }): Promise<void> {
+    if (mqttClient) {
+      mqttClient.removeAllListeners();
+      mqttClient.end(true)
+    }
+
+    mqttClient = mqtt.connect(endpoint, getMqttOptions({ username: params.userId, password: params.accessToken }))
+
+    mqttClient.on('connect', () => {
+      retryCount = 0
+      allowReconnection = true
+    })
+
+    mqttClient.on('error', (error: Error & { code: number }) => {
+      switch (error.code) {
+        case MqttError.IDENTIFIER_REJECTED:
+        case MqttError.BAD_USERNAME_OR_PASSWORD:
+        case MqttError.NOT_AUTHORIZED:
+          allowReconnection = false
+      }
+    })
+
+    mqttClient.on('close', () => {
+      if (allowReconnection) {
+        reconnect()
+      }
+    })
+
+    return new Promise(resolve => mqttClient!.once('connect', () => resolve()))
+  }
+
+  const reconnect = () => {
+    setTimeout(() => {
+      retryCount = retryCount + 1
+      mqttClient!.reconnect()
+    }, RETRY_BASE_TIMEOUT * Math.pow(2, retryCount > RETRY_COUNT_MAX ? RETRY_COUNT_MAX : retryCount))
+  }
+
+  return {
+    connect,
+    async disconnect(): Promise<void> {
+      allowReconnection = false
+
+      if (this.connected) {
+        return new Promise(resolve => mqttClient?.end(true, undefined, () => resolve()))
+      }
+    },
+    get connected() {
+      return !!mqttClient?.connected
+    },
+    on<T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) {
+      mqttClient?.on(event, handler)
+    },
+    once<T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) {
+      mqttClient?.once(event, handler)
+    },
+    off<T extends keyof Amity.MqttEvents>(event: T, handler?: (payload: Amity.MqttEvents[T]) => void) {
+      if (handler !== undefined) {
+        mqttClient?.off(event, handler)
+      } else {
+        mqttClient?.removeAllListeners(event)
+      }
+    },
+    removeAllListeners() {
+      mqttClient?.removeAllListeners()
+    },
+    subscribe(topic: string, callback?: Amity.Listener<ASCError | void>): Amity.Unsubscriber {
+      const callbackWrapper = (error: Error, granted: ISubscriptionGrant[]) => {
+        if (error || granted[0].qos === QOS_FAILURE_CODE) {
+          const ascError = error
+            ? new ASCError(error.message, Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR)
+            // TODO throw the actual error, once BE can tell us the actual error code
+            : new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR)
+
+          console.error(`Failed to subscribe to topic ${topic}`, ascError)
+          callback?.(ascError)
+        } else {
+          console.log(`Subscribed to topic ${granted[0].topic}`)
+          callback?.()
+        }
+      }
+
+      if (mqttClient) {
+        mqttClient.subscribe(topic, { qos: 0 }, callbackWrapper)
+      } else {
+        callbackWrapper(new Error('No connection to broker'), []);
+      }
+
+      return () => mqttClient?.unsubscribe(topic)
+    },
+    unsubscribe(topic: string) {
+      mqttClient?.unsubscribe(topic)
+    }
+  }
+}

package/src/core/transports/utils.ts

@@ -0,0 +1,25 @@
+import { ASCApiError, ASCUnknownError } from '~/core/errors'
+
+/**
+ * Unwraps v3 server payload (for error handling and type extraction)
+ *
+ * @param response A typical "v3" response (related to backend's service strategy)
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @hidden
+ */
+export const unwrapPayload = <T>(response: Amity.Response<T>): T => {
+  if (response.status === 'success') {
+    return response.data
+  } else if (response.status === 'fail') {
+    throw new ASCUnknownError(response.code)
+  } else if (response.status === 'error') {
+    throw new ASCApiError(response.message, response.code, Amity.ErrorLevel.ERROR)
+  }
+
+  // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
+  return undefined as unknown as T
+}

package/src/core/transports/ws.ts

@@ -0,0 +1,61 @@
+import io from 'socket.io-client'
+import { unwrapPayload } from './utils'
+
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The socket.io server's URL
+ * @returns A pre-configured (non-connected) socket.io client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createWebsocketTransport = (endpoint: string) => {
+  const socket = io(endpoint, {
+    autoConnect: false,
+    reconnectionDelay: 2000,
+    transports: ['websocket'],
+  })
+
+  // FIXME: disconnectClient removes this listener and client can get global ban event
+  socket.on('disconnect', (reason: string) => {
+    if (reason === 'io server disconnect')
+      socket.connect()
+  })
+
+  return socket
+}
+
+/**
+ * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
+ *
+ * @param client The current client for which to send the event with
+ * @param event The websocket event name
+ * @param data The event's payload
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @async
+ * @hidden
+ */
+export const synchronousWSCall = async <T>(
+  client: Amity.Client,
+  event: string,
+  data?: Object,
+)=> {
+  const { ws } = client
+
+  const value = await new Promise<T | undefined>((resolve, reject) => {
+    ws.emit(event, data, (response: Amity.Response<T>) => {
+      try {
+        resolve(unwrapPayload(response))
+      } catch (error) {
+        reject(error)
+      }
+    })
+  })
+
+  return value
+}

package/src/core/uuid.ts

@@ -0,0 +1,2 @@
+import nativeIdGenerator from 'react-native-uuid'
+export const uuid = () => nativeIdGenerator.v4().toString()

package/src/feed/api/index.ts

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

package/src/feed/api/queryGlobalFeed.ts

@@ -0,0 +1,47 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk'
+ * const posts = await queryGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ **/
+export const queryGlobalFeed = async (query?: {
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[]
+  page?: Amity.Page
+}): Promise<Amity.Paged<Amity.Post>> => {
+  const client = getActiveClient()
+  client.log('feed/queryGlobalFeed', query)
+
+  const { page, ...params } = query ?? {}
+
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+    `/api/v4/me/global-feeds`, { params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit')
+      },
+    } }
+  )
+
+  const { paging, ...payload } = data
+  const { posts } = payload
+
+  if (client.cache) ingestInCache(payload as Amity.PostPayload)
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: posts, prevPage, nextPage }
+}

package/src/file/api/createFile.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api'
+
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { createFile } from '@amityco/ts-sdk'
+ * const created = await createFile(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+export const createFile = async <T extends Amity.FileType = any>(
+  formData: FormData,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File>> => {
+  const client = getActiveClient()
+  client.log('file/createFile', formData)
+
+  if (!formData.getAll('file').length)
+    throw new Error('The formData object must have a `file` key.')
+
+  const headers = 'getHeaders' in formData
+    ? (formData as any).getHeaders()
+    : { 'content-type': 'multipart/form-data' }
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>(
+    '/api/v3/files', formData, {
+      headers, onUploadProgress({ loaded, total }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total))
+      }
+    }
+  )
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache({ files: data }, { cachedAt })
+
+  return {
+    data: data[0],
+    cachedAt,
+  }
+}
+
+// TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/deleteFile.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api'
+
+import { dropFromCache } from '~/cache/api'
+
+/**
+ * ```js
+ * import { deleteFile } from '@amityco/ts-sdk'
+ * const success = await deleteFile('foo')
+ * ```
+ *
+ * Deletes a {@link Amity.File}
+ *
+ * @param fileId The {@link Amity.File} ID to delete
+ * @return A success boolean if the {@link Amity.File} was deleted
+ *
+ * @category File API
+ * @async
+ */
+export const deleteFile = async (
+  fileId: Amity.File<any>['fileId'],
+): Promise<{success: boolean}> => {
+  const client = getActiveClient()
+  client.log('file/deleteFile', fileId)
+
+  // API-FIX: payload is different than swagger docs!!
+  await client.http.delete<{ fileId: string }>(
+    `/api/v3/files/${fileId}`,
+  )
+
+  dropFromCache(['file', 'get', fileId], true)
+
+  return { success: true }
+}

package/src/file/api/fileUrlWithSize.ts

@@ -0,0 +1,13 @@
+/**
+ * Allow to query a file url with a selected size
+ *
+ * @param fileUrl the file Url to decorate
+ * @param size one of the selected sizes
+ * @returns the computed url for the selected size
+ */
+export const fileUrlWithSize = (
+  fileUrl: Amity.File['fileUrl'],
+  size: 'small' | 'medium' | 'large' | 'full',
+) => {
+  return `${fileUrl}?size=${size}`
+}

package/src/file/api/getFile.ts

@@ -0,0 +1,72 @@
+import { getActiveClient } from '~/client/api'
+
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = await getFile('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object
+ *
+ * @param filelId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ * @async
+ */
+export const getFile = async <T extends Amity.FileType = any>(
+  fileId: Amity.File<any>['fileId'],
+): Promise<Amity.Cached<Amity.File>> => {
+  const client = getActiveClient()
+  client.log('file/getFile', fileId)
+
+  const { data } = await client.http.get<Amity.FilePayload<T>>(
+    `/api/v3/files/${fileId}`,
+  )
+
+  // API-FIX: backend bad serializer issue. it should be:
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache({files: [data]}, { cachedAt })
+
+  return {
+    data,
+    cachedAt,
+  }
+}
+
+/**
+ * ```js
+ * import { getFile } from '@amityco/ts-sdk'
+ * const file = getFile.locally('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.File} object from cache
+ *
+ * @param fileId the ID of the {@link Amity.File} to fetch
+ * @returns the associated {@link Amity.File} object
+ *
+ * @category File API
+ */
+getFile.locally = (
+  fileId: Amity.File<any>['fileId'],
+): Amity.Cached<Amity.File> | undefined => {
+  const client = getActiveClient()
+  client.log('file/getFile.locally', fileId)
+
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.File>(['file', 'get', fileId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
+}

package/src/file/api/index.ts

@@ -0,0 +1,4 @@
+export * from './getFile'
+export * from './createFile'
+export * from './deleteFile'
+export * from './fileUrlWithSize'

package/src/file/observers/index.ts

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

package/src/file/observers/observeFile.ts

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

package/src/index.ts

@@ -0,0 +1,55 @@
+// types
+import './@types'
+
+export * from './version'
+
+// sdk core
+export * from './core/query'
+export * from './core/subscription'
+export * from './cache/api'
+
+export * from './client/api'
+export * from './client/events'
+
+// asc core
+export * from './user/api'
+export * from './user/events'
+export * from './user/observers'
+
+export * from './file/api'
+export * from './file/observers'
+
+export * from './role/api'
+
+// // asc partials
+export * from './reaction/api'
+export * from './reaction/events'
+
+export * from './report/api'
+
+// // asc messaging
+export * from './channel/api'
+export * from './channel/events'
+export * from './channel/observers'
+
+export * from './message/api'
+export * from './message/events'
+export * from './message/observers'
+
+// // asc social
+export * from './community/api'
+export * from './community/events'
+export * from './community/observers'
+
+export * from './feed/api'
+
+export * from './post/api'
+export * from './post/events'
+export * from './post/observers'
+
+export * from './comment/api'
+export * from './comment/events'
+export * from './comment/observers'
+
+export * from './stream/api'
+export * from './stream/events'

package/src/message/api/createMessage.ts

@@ -0,0 +1,94 @@
+import { uuid } from '~/core/uuid'
+
+import { getActiveClient } from '~/client/api'
+
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk'
+ * const created = await createMessage({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ * @async
+ */
+export const createMessage = async <T extends Amity.MessageContentType>(
+  bundle: Pick<Amity.Message<T>, 'channelId' | 'type' | 'data' | 'metadata'>
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient()
+  client.log('user/createMessage', bundle)
+
+  const { data } = await client.http.post<Amity.MessagePayload>(
+    '/api/v3/messages', bundle,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache(data, { cachedAt })
+  // no need for event, fired by server
+
+  const { messages } = data
+
+  return {
+    data: messages[0],
+    cachedAt,
+  }
+}
+
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk'
+ * const created = createMessage.locally({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message} in cache
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ */
+createMessage.optimistically = (
+  bundle: Pick<Amity.Message, 'channelId' | 'type' | 'data' | 'metadata'>
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient()
+  client.log('user/createMessage.locally', bundle)
+
+  if (!client.cache) return
+
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundle.channelId])
+
+  upsertInCache(['channel', 'get', bundle.channelId], {
+    ...channel?.data,
+    messageCount: (channel?.data.messageCount ?? 0) + 1,
+  })
+
+  const message = {
+    messageId: Math.random().toString(16),
+    userId: client.userId,
+    channelSegment: (channel?.data.messageCount ?? 0) + 1,
+    createdAt: new Date().toISOString(),
+    ...bundle,
+  } as Amity.Message
+
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 })
+  fireEvent('v3.message.didCreate', { messages: [message] })
+
+  return {
+    data: message,
+    cachedAt: -1
+  }
+}