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

package/src/core/events.ts

@@ -3,15 +3,13 @@ import mitt from 'mitt'
 import { getActiveClient } from '~/client/api/activeClient'
 
 // need to sync up the list
-const EVENTS = [
+const WS_EVENTS = [
   'disconnected',
   'error',
   'connect_error',
   'reconnect_error',
   'reconnect_failed',
 
-  'v3.user.didUpdate',
-
   'v3.channel.didUpdate',
   'v3.channel.didUpdate',
   'v3.channel.didJoin',
@@ -26,6 +24,16 @@ const EVENTS = [
   'v3.message.didDelete',
 ] as const
 
+const MQTT_EVENTS = [
+  'connect',
+  'message',
+  'disconnect',
+  'error',
+  'close',
+  'end',
+  'reconnect'
+] as const;
+
 /** @hidden */
 export const createEventEmitter = () => {
   return mitt<Amity.Events>()
@@ -42,11 +50,24 @@ export const createEventEmitter = () => {
  * @hidden
  */
 export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
-  EVENTS.forEach(event => {
+  WS_EVENTS.forEach(event => {
     ws.on(event, (param: Amity.Events[typeof event]) => emitter.emit(event, param))
   })
 }
 
+export const proxyMqttEvents = (mqttClient: Amity.Client['mqtt'], emitter: Amity.Client['emitter']) => {
+  MQTT_EVENTS.forEach(event => {
+    mqttClient.on(event, (...params: any[]) => emitter.emit(event, params.length === 1 ? params[0] : params))
+  })
+
+  // @ts-ignore
+  mqttClient.on('message', (topic: string, payload: Buffer) => {
+    const message = JSON.parse(payload.toString());
+
+    emitter.emit(message.eventType, message.data)
+  })
+}
+
 /**
  * Standardize the subscription of SSE through web sockets
  *
@@ -83,6 +104,26 @@ export const createEventSubscriber = <T extends keyof Amity.Events>(
   }
 }
 
+export const createMqttMessageSubscriber = <T extends keyof Amity.Events>(
+  client: Amity.Client,
+  namespace: string,
+  event: string,
+  fn: (params: Object) => void,
+): Amity.Unsubscriber => {
+  return createEventSubscriber(
+    client,
+    namespace,
+    'message',
+    ([topic, message]) => {
+      const payload = JSON.parse(message.toString());
+
+      if (payload.eventType === event) {
+        fn(payload.data);
+      }
+    }
+  )
+}
+
 /**
  * Wrapper around dispatch event
  *

package/src/core/model/index.ts

@@ -1,3 +1,4 @@
 export * from './identifyModel'
 export * from './idResolvers'
 export * from './toRecord'
+export * from './isMatch'

package/src/core/model/isMatch.ts

@@ -0,0 +1,12 @@
+import isMatchWith from 'lodash.ismatchwith'
+
+/** @hidden */
+export const isMatch =<T extends Amity.Domain>(model1: Amity.Model[T], model2: Amity.Model[T]) => {
+  const customizer = (oldValue: any, newValue: any, key: string | number | symbol) => {
+    if (key === 'syncedAt') {
+      return true
+    }
+  }
+
+  return isMatchWith(model1, model2, customizer)
+}

package/src/core/network.ts

@@ -0,0 +1,14 @@
+export const API_ENDPOINT = {
+  EU: 'eu',
+  SG: 'sg',
+  US: 'us',
+} as const
+
+export enum UrlTemplate {
+  HTTP = 'https://api.{region}.amity.co',
+  MQTT = 'wss://sse.{region}.amity.co:443/mqtt',
+}
+
+export const getUrlFromTemplate = ( template: UrlTemplate, region: string ) => {
+  return template.replace( '{region}', region);
+}

package/src/core/subscription.ts

@@ -0,0 +1,75 @@
+import { getActiveClient } from '~/client/api'
+import { ASCError } from '~/core/errors'
+import { proxyMqttEvents } from '~/core/events'
+
+export enum SubscriptionLevels {
+  COMMUNITY = 'community',
+  POST = 'post',
+  COMMENT = 'comment',
+  POST_AND_COMMENT = 'post_and_comment',
+  USER = 'user',
+}
+
+const getCommunityUserTopic = (
+  { path }: Amity.Subscribable,
+  level?: SubscriptionLevels,
+): string => {
+  switch (level) {
+    case 'post':
+      return `${path}/post/+`;
+    case 'comment':
+      return `${path}/post/+/comment/+`;
+    case 'post_and_comment':
+      return `${path}/post/#`;
+    default:
+      return path;
+  }
+};
+
+export const getCommunityTopic = (
+  { path }: Amity.Subscribable,
+  level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
+): string =>
+  getCommunityUserTopic({ path }, level)
+
+export const getUserTopic = (
+  { path }: Amity.Subscribable,
+  level: Exclude<SubscriptionLevels, SubscriptionLevels.COMMUNITY> = SubscriptionLevels.USER,
+): string =>
+  getCommunityUserTopic({ path }, level)
+
+export const getPostTopic = (
+  { path }: Amity.Subscribable,
+  level: SubscriptionLevels.POST | SubscriptionLevels.COMMENT = SubscriptionLevels.POST
+): string => {
+  switch (level) {
+    case 'comment':
+      return `${path}/comment/+`;
+    default:
+      return path;
+  }
+};
+
+export const getCommentTopic = ({ path }: Amity.Subscribable): string => {
+  return path;
+};
+
+let mqttAccessToken: string;
+let mqttUserId: string;
+
+export function subscribeTopic(
+  topic: string,
+  callback?: Amity.Listener<ASCError | void>
+): Amity.Unsubscriber {
+  const { mqtt, emitter, accessToken, user } = getActiveClient()
+
+  if (mqttAccessToken !== accessToken || mqttUserId !== user!._id) {
+    mqttAccessToken = accessToken!
+    mqttUserId = user!._id
+
+    mqtt.connect({ accessToken: accessToken!, userId: user!._id })
+    proxyMqttEvents(mqtt, emitter)
+  }
+
+  return mqtt.subscribe(topic, callback)
+}

package/src/core/transports/http.ts

@@ -0,0 +1,63 @@
+import axios from 'axios'
+import HttpAgent, { HttpsAgent } from 'agentkeepalive'
+
+import { unwrapPayload } from './utils'
+
+/**
+ * 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) => {
+  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
+}

package/src/core/transports/index.ts

@@ -0,0 +1,3 @@
+export * from './http';
+export * from './ws';
+export * from './mqtt';

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/index.ts

@@ -7,6 +7,7 @@ export * from './version'
 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

@@ -44,13 +44,13 @@ export const deletePost = async (
   // later when realtime events covers that for us.
   if (post.targetType === 'community') {
     const community = await getCommunity(post.targetId);
-    fireEvent('v3.community.didUpdate', { communities: [community] })
+    fireEvent('community.updated', { communities: [community] })
   }
 
   // to support hard deletion
   const deleted = { ...post, isDeleted: true }
 
-  fireEvent('v3.post.didDelete', { posts: [deleted] })
+  fireEvent('post.deleted', { posts: [deleted] })
 
   if (permanent) {
     setTimeout(() => {

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)