@amityco/ts-sdk 0.0.1-02f0fa3.0

package/src/core/transports.ts

@@ -0,0 +1,157 @@
+import axios from 'axios'
+import HttpAgent, { HttpsAgent } from 'agentkeepalive'
+
+import io from 'socket.io-client'
+
+import {
+  ASCApiError,
+  ASCUnknownError,
+  ASCConnectionError,
+} from './errors'
+
+/**
+ * Axios param serializer (for querystring)
+ * @hidden
+ */
+const stringify = (params: object, prefix?: string): string => {
+  return Object.entries(params)
+    .filter(([, value]) => value !== undefined)
+    .map(([name, value]) => {
+      const key = prefix ? `${prefix}[${name}]` : name
+
+      if (Array.isArray(value)) {
+        return value.map(item => `${key}[]=${item}`).join('&')
+      } else if (typeof value !== 'object') {
+        return `${key}=${value}`
+      }
+
+      return stringify(value, prefix ?? name)
+    })
+    .join('&')
+}
+
+/**
+ * Creates a pre-configured axios instance
+ *
+ * @param endpoint The ASC rest api server's URL
+ * @returns A pre-configured axios instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createHttpTransport = (endpoint: string = 'https://api.amity.co') => {
+  const options = {
+    maxSockets: 100,
+    maxFreeSockets: 10,
+    timeout: 60000,
+    freeSocketTimeout: 30000,
+  }
+
+  const instance = axios.create({
+    baseURL: endpoint,
+    httpAgent: new HttpAgent(options),
+    httpsAgent: new HttpsAgent(options),
+    paramsSerializer: stringify,
+  })
+
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      const { response } = error
+      console.error(response?.data ?? error)
+
+      if (response)
+        unwrapPayload(response.data)
+    }
+  )
+
+  return instance
+}
+
+/**
+ * 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 = 'https://api.ekomedia.technology') => {
+  const socket = io(endpoint, {
+    autoConnect: false,
+    reconnectionDelay: 2000,
+    transports: ['websocket'],
+  })
+
+  socket.on('disconnect', (reason: string) => {
+    if (reason === 'io server disconnect')
+      socket.connect()
+  })
+
+  ;['error', 'connect_error', 'connect_timeout', 'reconnect_error', 'reconnect_failed'].forEach(event => {
+    socket.on(event, (error: Error) => {
+      throw new ASCConnectionError(`socket.io(${event}): ${error.message}`)
+    })
+  })
+
+  return socket
+}
+
+/**
+ * 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
+}
+
+/**
+ * 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,50 @@
+import { getActiveClient } from '~/client/api/activeClient'
+
+import { ingestInCache } from '~/core/cache'
+import { toRecord } from '~/core/model'
+import { decoratePayload, toPage, toToken } from '~/core/query'
+
+/**
+ * ```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')[]
+  page?: Amity.Page
+}) => {
+  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, ...response } = data
+
+  decoratePayload(response as unknown as Record<string, object[]>)
+  ingestInCache(response as unknown as Record<string, object[]>)
+
+  const { posts } = response
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: toRecord(posts), nextPage, prevPage }
+}

package/src/file/api/createFile.ts

@@ -0,0 +1,51 @@
+import { getActiveClient } from '~/client/api'
+
+import { decorateModels } from '~/core/query'
+import { ingestInCache } from '~/core/cache'
+
+/**
+ * ```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,
+) => {
+  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
+
+  decorateModels(data)
+  ingestInCache({ files: data })
+
+  return data[0]
+}
+
+// TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/deleteFile.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '~/client/api'
+
+import { mergeInCache } from '~/core/cache'
+
+/**
+ * ```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'],
+) => {
+  const client = getActiveClient()
+  client.log('file/deleteFile', fileId)
+
+  const { data } = await client.http.delete<{ success: boolean }>(
+    `/api/v3/files/${fileId}`,
+  )
+
+  const { success } = data
+
+  if (success)
+    mergeInCache('file', { fileId, isDeleted: true })
+
+  return success
+}

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,60 @@
+import { getActiveClient } from '~/client/api'
+
+import { decorateModel } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+
+/**
+ * ```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'],
+) => {
+  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
+
+  decorateModel(data)
+  ingestInCache({ files: [data] })
+
+  return data
+}
+
+/**
+ * ```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'],
+) => {
+  const client = getActiveClient()
+  client.log('file/getFile.locally', fileId)
+
+  const [file] = pullFromCache('file', fileId) ?? []
+  return file
+}

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,57 @@
+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.QueryResult<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.QueryResult<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'
+
+// sdk core
+export * from './core/query'
+export * from './core/cache'
+export * from './core/stores'
+
+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'
+
+// asc video
+// not usable for now
+// export * from './stream/api'
+// export * from './stream/events'

package/src/message/api/createMessage.ts

@@ -0,0 +1,90 @@
+import { uuid } from '~/core/uuid'
+
+import { getActiveClient } from '~/client/api'
+
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache, pushToCache } from '~/core/cache'
+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'>
+) => {
+  const client = getActiveClient()
+  client.log('user/createMessage', bundle)
+
+  const { data } = await client.http.post<Amity.MessagePayload>(
+    '/api/v3/messages', bundle,
+  )
+
+  decoratePayload(data)
+  ingestInCache(data)
+  // no need for event, fired by server
+
+  const { messages } = data
+  return messages[0]
+}
+
+/**
+ * ```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'>
+) => {
+  const client = getActiveClient()
+  client.log('user/createMessage.locally', bundle)
+
+  // should we do this?
+  if (!client.cache) return
+
+  const [channel] = pullFromCache('channel', bundle.channelId) ?? []
+
+  pushToCache('channel', {
+    ...channel,
+    messageCount: (channel.messageCount ?? 0) + 1,
+  })
+
+  const message = {
+    localId: uuid(),
+    messageId: Math.random().toString(16),
+    userId: client.userId,
+    channelSegment: (channel?.messageCount ?? 0) + 1,
+    createdAt: new Date().toISOString(),
+    ...bundle,
+    syncedAt: -1,
+  } as Amity.Message
+
+  pushToCache('message', message)
+  fireEvent('v3.message.didCreate', { messages: [message] })
+
+  return message
+}

package/src/message/api/deleteMessage.ts

@@ -0,0 +1,75 @@
+import { getActiveClient } from '~/client/api'
+
+import { getMessage } from './getMessage'
+
+import {
+  pullFromCache,
+  pushToCache,
+} from '~/core/cache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = await deleteMessage('foobar')
+ * ```
+ *
+ * Delete a {@link Amity.Message}
+ *
+ * @param The ID of the {@link Amity.Message} to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ * @async
+ */
+export const deleteMessage = async (
+  messageId: Amity.Message['messageId'],
+) => {
+  const client = getActiveClient()
+  client.log('message/deleteMessage', messageId)
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/messages/${messageId}`
+  )
+
+  const deleted = await getMessage(messageId)
+  // no need for event, fired by server
+
+  return deleted
+}
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = deleteMessage.locally('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Message}
+ *
+ * @param messageId The {@link Amity.Message} ID to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ */
+deleteMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+) => {
+  const client = getActiveClient()
+  client.log('message/deleteMessage', messageId)
+
+  const [message] = pullFromCache('message', messageId) ?? []
+
+  if (!message) return
+
+  const deleted: Amity.Message = {
+    ...message,
+    isDeleted: true,
+    updatedAt: new Date().toISOString(),
+  }
+
+  pushToCache('message', deleted)
+  fireEvent('v3.message.didDelete', { messages: [deleted] })
+
+  return deleted
+}