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

package/src/@types/core/transport.ts

@@ -1,3 +1,5 @@
+import { ASCError } from '~/core/errors'
+
 export {}
 
 declare global {
@@ -28,5 +30,17 @@ declare global {
         next?: Token
       }
     }
+
+    type MqttClient = {
+      connect: (params: { accessToken: string, userId: string }) => Promise<void>
+      disconnect: () => Promise<void>
+      get connected(): boolean
+      on: <T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) => void
+      once: <T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) => void
+      off: <T extends keyof Amity.MqttEvents>(event: T, handler?: (payload: Amity.MqttEvents[T]) => void) => void
+      removeAllListeners: () => void
+      subscribe: (topic: string, callback?: Amity.Listener<ASCError | void>) => Amity.Unsubscriber
+      unsubscribe: (topic: string) => void
+    }
   }
 }

package/src/@types/domains/client.ts

@@ -10,6 +10,7 @@ declare global {
 
       log: Logger
       http: AxiosInstance
+      mqtt: Amity.MqttClient
       ws: SocketIOClient.Socket
       emitter: Emitter<Amity.Events>
 
@@ -17,6 +18,8 @@ declare global {
 
       apiKey?: string
       userId?: string
+      user?: Amity.User
+      accessToken?: string
 
       use: () => void
     }

package/src/@types/domains/comment.ts

@@ -22,5 +22,6 @@ declare global {
     & Amity.Timestamps
     & Amity.SoftDelete
     & Amity.Syncable
+    & Amity.Subscribable
   }
 }

package/src/@types/domains/community.ts

@@ -31,5 +31,6 @@ declare global {
     & Amity.Timestamps
     & Amity.SoftDelete
     & Amity.Syncable
+    & Amity.Subscribable
   }
 }

package/src/@types/domains/group.ts

@@ -13,12 +13,12 @@ declare global {
     } & (
       T extends 'channel' ? {
         channelId: Amity.Channel['channelId']
-        membership: 'member' | 'notMember' | 'banned'
+        membership: 'member' | 'none' | 'banned'
         readToSegment: number
       } :
       T extends 'community' ? {
         communityId: Amity.Community['communityId']
-        communityMembership: 'member' | 'notMember' | 'banned'
+        communityMembership: 'member' | 'none' | 'banned'
       } :
       never
     )

package/src/@types/domains/partials.ts

@@ -48,5 +48,9 @@ declare global {
         roles: Amity.Role['displayName'][]
         permissions: Amity.Permission[]
     }
+
+    type Subscribable = {
+      path: string
+    }
   }
 }

package/src/@types/domains/post.ts

@@ -27,5 +27,6 @@ declare global {
       Amity.Timestamps &
       Amity.SoftDelete &
       Amity.Syncable
+      & Amity.Subscribable
   }
 }

package/src/@types/domains/user.ts

@@ -3,6 +3,7 @@ export {}
 declare global {
   namespace Amity {
     type User = {
+      _id: string
       userId: string
       displayName?: string
       avatarFileId?: Amity.File<'image'>['fileId']
@@ -14,5 +15,6 @@ declare global {
     & Amity.Accredited
     & Amity.Timestamps
     & Amity.Syncable
+    & Amity.Subscribable
   }
 }

package/src/client/api/connectClient.ts

@@ -1,9 +1,11 @@
+import { disconnectClient } from '~/client/api/disconnectClient'
 import { getDeviceId } from '~/core/device'
-import { proxyWebsocketEvents } from '~/core/events'
+import { proxyMqttEvents, proxyWebsocketEvents } from '~/core/events'
 
 import { getActiveClient } from './activeClient'
 
 import { getToken } from './getToken'
+import { onClientBanned } from '../events'
 
 /**
  * ```js
@@ -39,7 +41,7 @@ export const connectClient = async (params: {
 
   // @ts-ignore: in that particular case, typing can be
   // ignored since we enforce default values just before.
-  const { accessToken } = await getToken(params)
+  const { accessToken, users } = await getToken(params)
 
   // manually setup the token for http transport
   client.http.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`
@@ -47,6 +49,7 @@ export const connectClient = async (params: {
   // 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)
 
@@ -57,7 +60,14 @@ export const connectClient = async (params: {
     client.ws.open()
   })
 
+  const unsubscribe = onClientBanned(() => {
+    disconnectClient()
+    unsubscribe()
+  })
+
   client.userId = params.userId
+  client.user = users[0]
+  client.accessToken = accessToken
 
   return client.ws.connected
 }

package/src/client/api/createClient.ts

@@ -2,10 +2,8 @@ import { VERSION } from '~/version'
 
 import { createLogger } from '~/core/debug'
 
-import {
-  createHttpTransport,
-  createWebsocketTransport,
-} from '~/core/transports'
+import { API_ENDPOINT, getUrlFromTemplate, UrlTemplate } from '~/core/network'
+import { createHttpTransport, createMqttTransport, createWebsocketTransport } from '~/core/transports'
 
 import { createEventEmitter } from '~/core/events'
 
@@ -28,7 +26,7 @@ import { getActiveClient, setActiveClient } from './activeClient'
  **/
 export const createClient = (
   apiKey: string,
-  apiEndpoint: string = 'https://api.amity.co',
+  apiEndpoint: typeof API_ENDPOINT[keyof typeof API_ENDPOINT]|string = API_ENDPOINT.SG,
   debugSession: string = 'amity'
 ): Amity.Client => {
   const log = createLogger(debugSession)
@@ -38,8 +36,9 @@ export const createClient = (
     apiEndpoint,
   })
 
-  const http = createHttpTransport(apiEndpoint)
-  const ws = createWebsocketTransport(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()
 
@@ -50,6 +49,7 @@ export const createClient = (
     log,
     http,
     ws,
+    mqtt,
     emitter,
     use: () => setActiveClient(client),
   }

package/src/client/api/disconnectClient.ts

@@ -21,11 +21,16 @@ export const disconnectClient = async (): Promise<boolean> => {
   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.user = undefined
+  client.accessToken = undefined
 
   return !client.ws.connected
 }

package/src/client/api/getToken.ts

@@ -25,7 +25,7 @@ export const getToken = async (params: {
 
   const deviceInfo = await getDeviceInfo()
 
-  const { data } = await client.http.post<Amity.Tokens>('/v1/device', {
+  const { data } = await client.http.post<Amity.Tokens & { users: Amity.User[] }>('/v1/device', {
     ...params, deviceInfo,
   } , {
     //@ts-ignore

package/src/client/events/onConnectionError.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api/activeClient'
 
 import { createEventSubscriber } from '~/core/events'
 

package/src/comment/api/createComment.ts

@@ -35,8 +35,8 @@ export const createComment = async <T extends Amity.CommentContentType>(
 
   const post = await getPost(bundle.referenceId)
 
-  fireEvent('v3.post.didUpdate', { posts: [post] })
-  fireEvent('v3.comment.didCreate', data)
+  fireEvent('post.updated', { posts: [post] })
+  fireEvent('comment.created', data)
 
   const { comments } = data
   return comments[0]

package/src/comment/api/deleteComment.ts

@@ -44,8 +44,8 @@ export const deleteComment = async (
 
   const post = await getPost(comment.referenceId)
 
-  fireEvent('v3.post.didUpdate', { posts: [post] })
-  fireEvent('v3.comment.didDelete', { comments: [deleted] })
+  fireEvent('post.updated', { posts: [post] })
+  fireEvent('comment.deleted', { comments: [deleted] })
 
 
   if (permanent) {

package/src/comment/api/updateComment.ts

@@ -34,7 +34,7 @@ export const updateComment = async (
 
   decoratePayload(data)
   ingestInCache(data)
-  fireEvent('v3.comment.didUpdate', data)
+  fireEvent('comment.updated', data)
 
   const { comments } = data
   return comments.find(comment => comment.commentId === commentId)!

package/src/comment/events/index.ts

@@ -1,3 +1,9 @@
 export * from './onCommentCreated'
 export * from './onCommentUpdated'
 export * from './onCommentDeleted'
+
+export * from './onCommentFlagged'
+export * from './onCommentUnflagged'
+
+export * from './onCommentReactionAdded'
+export * from './onCommentReactionRemoved'

package/src/comment/events/onCommentCreated.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 { createCommentEventSubscriber } from './utils'
 
 /**
  * ```js
@@ -12,7 +8,7 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been created
+ * Fired when {@link Amity.Comment} has been created
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
@@ -21,19 +17,5 @@ import { ingestInCache } from '~/core/cache'
  */
 export const onCommentCreated = <T extends Amity.CommentContentType>(
   callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onCommentCreated',
-    'v3.comment.didCreate',
-    filter
-  )
-}
+): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.created', callback)

package/src/comment/events/onCommentDeleted.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 { createCommentEventSubscriber } from './utils'
 
 /**
  * ```js
@@ -12,7 +8,7 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been deleted
+ * Fired when a {@link Amity.Comment} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
@@ -21,19 +17,5 @@ import { ingestInCache } from '~/core/cache'
  */
 export const onCommentDeleted = <T extends Amity.CommentContentType>(
   callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onCommentDeleted',
-    'v3.comment.didDelete',
-    filter
-  )
-}
+): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.deleted', callback)

package/src/comment/events/onCommentFlagged.ts

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

package/src/comment/events/onCommentReactionAdded.ts

@@ -0,0 +1,52 @@
+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 { onCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentReactionAdded = <T extends Amity.CommentContentType>(
+  callback: Amity.Listener<Amity.Comment<T>>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload<T> & { reactor: Amity.Reaction }) => {
+    const [cached] = pullFromCache('comment', payload.comments[0].commentId) ?? []
+
+    const { reactor, ...commentPayload } = payload;
+
+    decoratePayload(commentPayload as Amity.CommentPayload<T>)
+    preparePayloadForCache('comment.addReaction', payload)
+    ingestInCache(commentPayload as Amity.CommentPayload<T>)
+
+    const [comment] = pullFromCache('comment', payload.comments[0].commentId) ?? []
+
+    if (cached && isMatch(cached, comment)) {
+      return
+    }
+
+    callback(comment)
+  }
+
+  return createEventSubscriber(
+    client,
+    'comment.addReaction',
+    'comment.addReaction',
+    filter
+  )
+}

package/src/comment/events/onCommentReactionRemoved.ts

@@ -0,0 +1,52 @@
+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 { onCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentReactionRemoved = <T extends Amity.CommentContentType>(
+  callback: Amity.Listener<Amity.Comment<T>>
+): Amity.Unsubscriber => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload<T> & { reactor: Amity.Reaction }) => {
+    const [cached] = pullFromCache('comment', payload.comments[0].commentId) ?? []
+
+    const { reactor, ...commentPayload } = payload;
+
+    decoratePayload(commentPayload as Amity.CommentPayload<T>)
+    preparePayloadForCache('comment.removeReaction', payload)
+    ingestInCache(commentPayload as Amity.CommentPayload<T>)
+
+    const [comment] = pullFromCache('comment', payload.comments[0].commentId) ?? []
+
+    if (cached && isMatch(cached, comment)) {
+      return
+    }
+
+    callback(comment)
+  }
+
+  return createEventSubscriber(
+    client,
+    'comment.removeReaction',
+    'comment.removeReaction',
+    filter
+  )
+}

package/src/comment/events/onCommentUnflagged.ts

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

package/src/comment/events/onCommentUpdated.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 { createCommentEventSubscriber } from './utils'
 
 /**
  * ```js
@@ -12,7 +8,7 @@ import { ingestInCache } from '~/core/cache'
  * })
  * ```
  *
- * Fired when an {@link Amity.Comment} has been updated
+ * Fired when a {@link Amity.Comment} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
@@ -21,19 +17,5 @@ import { ingestInCache } from '~/core/cache'
  */
 export const onCommentUpdated = <T extends Amity.CommentContentType>(
   callback: Amity.Listener<Amity.Comment<T>>
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommentPayload<T>) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.comments[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'message/onCommentUpdated',
-    'v3.comment.didUpdate',
-    filter
-  )
-}
+): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.updated', callback)

package/src/comment/events/utils.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { isMatch } from '~/core/model'
+
+export const createCommentEventSubscriber = <T extends Amity.CommentContentType>(
+  event: keyof Amity.MqttCommentMessageEvents,
+  callback: Amity.Listener<Amity.Comment<T>>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommentPayload<T>) => {
+    const [cached] = pullFromCache('comment', payload.comments[0].commentId) ?? []
+
+    decoratePayload(payload)
+    ingestInCache(payload)
+
+    const [comment] = pullFromCache('comment', payload.comments[0].commentId) ?? []
+
+    if (cached && isMatch(cached, comment)) {
+      return
+    }
+
+    callback(comment)
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}

package/src/comment/observers/observeComment.ts

@@ -7,6 +7,10 @@ import { getComment } from '../api'
 import {
   onCommentUpdated,
   onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
 } from '../events'
 
 
@@ -26,7 +30,7 @@ import {
  *
  * @category Comment Observer
  */
-export const observeComment = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+export const observeComment = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>(
   commentId: string,
   callback: Amity.ObjectListener<Amity.QueryResult<Amity.Comment>, Events>,
   policy: Amity.QueryPolicy = 'cache_then_server',
@@ -41,9 +45,6 @@ export const observeComment = <Events extends ['onFetch', 'onUpdate', 'onDelete'
     result: Amity.QueryResult<Amity.Comment>,
     action: Events[number]
   ) => {
-    // filter function
-    if (result.data?.commentId !== commentId) return
-
     if (callback instanceof Function)
       return callback(result)
 
@@ -53,16 +54,29 @@ export const observeComment = <Events extends ['onFetch', 'onUpdate', 'onDelete'
     callback[action]?.(result)
   }
 
+  const realtimeRouter = (
+    result: Amity.QueryResult<Amity.Comment>,
+    action: Events[number]
+  ) => {
+    if (result.data?.commentId !== commentId) return
+
+    router(result, action)
+  }
+
   const disposers: Amity.Unsubscriber[] = []
 
   disposers.push(
-    onCommentUpdated(data => router({ data }, 'onUpdate')),
-    onCommentDeleted(data => router({ data }, 'onDelete')),
+    onCommentUpdated(data => realtimeRouter({ data }, 'onUpdate')),
+    onCommentDeleted(data => realtimeRouter({ data }, 'onDelete')),
+    onCommentFlagged(data => realtimeRouter({ data }, 'onFlagged')),
+    onCommentUnflagged(data => realtimeRouter({ data }, 'onUnflagged')),
+    onCommentReactionAdded(data => realtimeRouter({ data }, 'onReactionAdded')),
+    onCommentReactionRemoved(data => realtimeRouter({ data }, 'onReactionRemoved')),
   )
 
   runQuery(
     createQuery(getComment, commentId),
-    result => result.data && router(result, 'onFetch'),
+    result => router(result, 'onFetch'),
     queryOptions(policy)
   )