@amityco/ts-sdk 0.0.1-beta.5 → 0.0.1-beta.9

package/src/core/transports/mqtt.ts

@@ -0,0 +1,141 @@
+import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from '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/feed/api/queryGlobalFeed.ts

@@ -19,7 +19,7 @@ import { decoratePayload, toPage, toToken } from '~/core/query'
  * @async
  **/
 export const queryGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file')[]
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[]
   page?: Amity.Page
 }) => {
   const client = getActiveClient()

package/src/file/api/deleteFile.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
-import { mergeInCache } from '~/core/cache'
+import { dropFromCache } from '~/core/cache'
 
 /**
  * ```js
@@ -22,14 +22,13 @@ export const deleteFile = async (
   const client = getActiveClient()
   client.log('file/deleteFile', fileId)
 
-  const { data } = await client.http.delete<{ success: boolean }>(
+    // API-FIX: payload is different than swagger docs!!
+  const { data } = await client.http.delete<{ fileId: string }>(
     `/api/v3/files/${fileId}`,
   )
 
-  const { success } = data
+  dropFromCache('file', {fileId: data.fileId})
 
-  if (success)
-    mergeInCache('file', { fileId, isDeleted: true })
 
-  return success
+  return { success: true }
 }

package/src/index.ts

@@ -1,10 +1,13 @@
 // types
 import './@types'
 
+export * from './version'
+
 // sdk core
 export * from './core/query'
 export * from './core/cache'
 export * from './core/stores'
+export * from './core/subscription'
 
 export * from './client/api'
 export * from './client/events'

package/src/post/api/createPost.ts

@@ -41,8 +41,8 @@ export const createPost = async <T extends Amity.PostContentType | string>(
   decoratePayload(data)
   ingestInCache(data)
 
-  fireEvent('v3.community.didUpdate', { communities: data.communities! })
-  fireEvent('v3.post.didCreate', data)
+  fireEvent('community.updated', { communities: data.communities! })
+  fireEvent('post.created', data)
 
   const { posts } = data
   return posts[0]

package/src/post/api/deletePost.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api'
 import { getCommunity } from '~/community/api'
 import { fireEvent } from '~/core/events'
+import { dropFromCache, mergeInCache } from '~/core/cache'
 
 import { getPost } from './getPost'
 
@@ -20,24 +21,44 @@ import { getPost } from './getPost'
  */
 export const deletePost = async (
   postId: Amity.Post['postId'],
+  permanent: boolean = false,
 ) => {
   const client = getActiveClient()
   client.log('post/deletePost', postId)
 
+  let post = await getPost(postId)
+
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
-    `/api/v3/posts/${postId}`,
+    `/api/v4/posts/${postId}`, {
+      params: {
+        postId,
+        permanent,
+      },
+    },
   )
 
-  // API-FIX: as for now we have no choice but to refetch
-  const deleted = await getPost(postId)
-
-  if (deleted.targetType === 'community') {
-    const community = await getCommunity(deleted.targetId);
-    fireEvent('v3.community.didUpdate', { communities: [community] })
+  // there is currently a limitation which doesn't allow us to fire event to tell that community
+  // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
+  // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+  // later when realtime events covers that for us.
+  if (post.targetType === 'community') {
+    const community = await getCommunity(post.targetId);
+    fireEvent('community.updated', { communities: [community] })
   }
 
-  fireEvent('v3.post.didDelete', { posts: [deleted] })
+  // to support hard deletion
+  const deleted = { ...post, isDeleted: true }
+
+  fireEvent('post.deleted', { posts: [deleted] })
+
+  if (permanent) {
+    setTimeout(() => {
+      dropFromCache('post', {postId})
+    }, 0)
+  } else {
+    mergeInCache('post', {postId, isDeleted: true})
+  }
 
   return deleted
 }

package/src/post/api/getPost.ts

@@ -1,5 +1,5 @@
 import { getActiveClient } from '~/client/api'
-import { ingestInCache, pullFromCache } from '~/core/cache'
+import { ingestInCache, pullFromCache, dropFromCache } from '~/core/cache'
 import { decoratePayload } from '~/core/query'
 
 import { getPosts } from './getPosts'
@@ -24,10 +24,22 @@ export const getPost = async (
   const client = getActiveClient()
   client.log('post/getPost', postId)
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.PostPayload>(
-    `/api/v3/posts/${postId}`,
-  )
+  let data: Amity.PostPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.PostPayload>(
+      `/api/v3/posts/${postId}`,
+    )
+
+    data = response.data;
+  } catch (error) {
+    if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
+      dropFromCache('post', {postId})
+    }
+
+    throw error;
+  }
 
   decoratePayload(data)
   ingestInCache(data)

package/src/post/api/updatePost.ts

@@ -35,7 +35,7 @@ export const updatePost = async (
   decoratePayload(data)
   ingestInCache(data)
 
-  fireEvent('v3.post.didUpdate', data)
+  fireEvent('post.updated', data)
 
   const { posts } = data
   return posts.find(post => post.postId === postId)!

package/src/post/events/index.ts

@@ -1,3 +1,12 @@
 export * from './onPostCreated'
 export * from './onPostUpdated'
 export * from './onPostDeleted'
+
+export * from './onPostApproved'
+export * from './onPostDeclined'
+
+export * from './onPostFlagged'
+export * from './onPostUnflagged'
+
+export * from './onPostReactionAdded'
+export * from './onPostReactionRemoved'

package/src/post/events/onPostApproved.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostApproved } from '@amityco/ts-sdk'
+ * const dispose = onPostApproved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostApproved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.approved', callback)

package/src/post/events/onPostCreated.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createPostEventSubscriber } from './utils'
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been created
+ * Fired when {@link Amity.Post} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Post Events
  */
-export const onPostCreated = (
-  callback: Amity.Listener<Amity.Post>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onPostCreated',
-    'v3.post.didCreate',
-    filter
-  )
-}
+export const onPostCreated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.created', callback)

package/src/post/events/onPostDeclined.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostDeclined } from '@amityco/ts-sdk'
+ * const dispose = onPostDeclined(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostDeclined = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.declined', callback)

package/src/post/events/onPostDeleted.ts

@@ -1,8 +1,4 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createPostEventSubscriber } from './utils'
 
 /**
  * ```js
@@ -12,28 +8,12 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Post} has been deleted
+ * Fired when a {@link Amity.Post} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Post Events
  */
-export const onPostDeleted = (
-  callback: Amity.Listener<Amity.Post>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.PostPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.posts[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onPostDeleted',
-    'v3.post.didDelete',
-    filter
-  )
-}
+export const onPostDeleted = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.deleted', callback)

package/src/post/events/onPostFlagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostFlagged } from '@amityco/ts-sdk'
+ * const dispose = onPostFlagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostFlagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.flagged', callback)

package/src/post/events/onPostReactionAdded.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils'
+import { isMatch } from '~/core/model'
+
+/**
+ * ```js
+ * import { onPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Post} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.addReaction']) => {
+    const [cached] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    const { reactor, ...postPayload } = payload;
+
+    decoratePayload(postPayload as Amity.PostPayload)
+    preparePayloadForCache('post.addReaction', payload)
+    ingestInCache(postPayload as Amity.PostPayload)
+
+    const [post] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    if (cached && isMatch(cached, post)) {
+      return
+    }
+
+    callback(post)
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.addReaction',
+    'post.addReaction',
+    filter
+  )
+}

package/src/post/events/onPostReactionRemoved.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { preparePayloadForCache } from '~/reaction/utils/preparePayloadForCache'
+import { isMatch } from '~/core/model'
+
+/**
+ * ```js
+ * import { onPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.Events['post.removeReaction']) => {
+    const [cached] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    const { reactor, ...postPayload } = payload;
+
+    decoratePayload(postPayload as Amity.PostPayload)
+    preparePayloadForCache('post.removeReaction', payload)
+    ingestInCache(postPayload as Amity.PostPayload)
+
+    const [post] = pullFromCache('post', payload.posts[0].postId) ?? []
+
+    if (cached && isMatch(cached, post)) {
+      return
+    }
+
+    callback(post)
+  }
+
+  return createEventSubscriber(
+    client,
+    'post.removeReaction',
+    'post.removeReaction',
+    filter
+  )
+}

package/src/post/events/onPostUnflagged.ts

@@ -0,0 +1,19 @@
+import { createPostEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onPostUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onPostUnflagged(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Post}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+export const onPostUnflagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
+  createPostEventSubscriber('post.unflagged', callback)