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

package/src/community/events/onCommunityUpdated.ts

@@ -1,37 +1,19 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
-
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { createCommunityEventSubscriber } from './utils'
 
 /**
  * ```js
  * import { onCommunityUpdated } from '@amityco/ts-sdk'
- * const dispose = onCommunityUpdated(channel => {
+ * const dispose = onCommunityUpdated(community => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a {@link Amity.Community} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-export const onCommunityUpdated = (callback: Amity.Listener<Amity.Community>) => {
-  const client = getActiveClient()
-
-  const filter = (payload: Amity.CommunityPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.communities[0])
-  }
-
-  return createEventSubscriber(
-    client,
-    'onCommunityUpdated',
-    'v3.community.didUpdate',
-    filter
-  )
-}
+export const onCommunityUpdated = (callback: Amity.Listener<Amity.Community>) =>
+  createCommunityEventSubscriber('community.updated', callback)

package/src/community/events/onCommunityUserAdded.ts

@@ -0,0 +1,19 @@
+import { createCommunityMemberEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onCommunityUserAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserAdded((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been added to a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserAdded = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userAdded', callback)

package/src/community/events/onCommunityUserBanned.ts

@@ -0,0 +1,19 @@
+import { createCommunityMemberEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onCommunityUserBanned } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserBanned((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been banned in a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserBanned = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userBanned', callback)

package/src/community/events/onCommunityUserRemoved.ts

@@ -0,0 +1,19 @@
+import { createCommunityMemberEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onCommunityUserRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserRemoved((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been removed from a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserRemoved = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userRemoved', callback)

package/src/community/events/onCommunityUserUnbanned.ts

@@ -0,0 +1,19 @@
+import { createCommunityMemberEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onCommunityUserUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUserUnbanned((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been unbanned in a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUserUnbanned = (callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void) =>
+  createCommunityMemberEventSubscriber('community.userUnbanned', callback)

package/src/community/events/utils.ts

@@ -0,0 +1,108 @@
+import { getActiveClient } from '~/client/api'
+import { decoratePayload } from '~/core/query'
+import { ingestInCache, pullFromCache } from '~/core/cache'
+import { createEventSubscriber } from '~/core/events'
+import { getResolver, isMatch } from '~/core/model'
+
+export const createCommunityEventSubscriber = (
+  event: keyof Amity.MqttCommunityMessageEvents,
+  callback: Amity.Listener<Amity.Community>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommunityPayload) => {
+    const [cached] = pullFromCache('community', payload.communities[0].communityId) ?? []
+
+    decoratePayload(payload)
+    ingestInCache(payload)
+
+    const [community] = pullFromCache('community', payload.communities[0].communityId) ?? []
+
+    if (cached && isMatch(cached, community)) {
+      return
+    }
+
+    callback(community)
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}
+
+function hasPermission(member: Amity.Membership<'community'>, payload: Amity.CommunityPayload, permission: string) {
+  if (member.permissions.some(x => x === permission)) {
+    return true;
+  }
+
+  return payload.users!
+    .find(user => user.userId === member.userId)!
+    .permissions.some(x => x === permission)
+}
+
+
+function getEventRelatedMember(
+  event: keyof Amity.MqttCommunityUserMessageEvents,
+  payload: Amity.CommunityPayload
+)  {
+  if (event === 'community.joined' || event === 'community.left') {
+    return payload.communityUsers![0];
+  }
+
+  // NOTE: backend returns the one who took the action and the one on whom
+  // the action was taken. We need the 2nd one
+  if (event === 'community.userRemoved') {
+    return payload.communityUsers!.filter(x => x.communityMembership === 'none')[0]
+  }
+
+  if (event === 'community.userBanned') {
+    return payload.communityUsers!.filter(x => x.communityMembership === 'banned')[0]
+  }
+
+  // NOTE: it might be that in certain edge cases permission check won't be enough
+  if (event === 'community.userUnbanned') {
+    return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'))[0]
+  }
+
+  return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'))[0]
+}
+
+export const createCommunityMemberEventSubscriber = (
+  event: keyof Amity.MqttCommunityUserMessageEvents,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.CommunityPayload) => {
+    const [cachedCommunity] = pullFromCache('community', payload.communities[0].communityId) ?? []
+    const [cachedMember] = pullFromCache(
+      'communityUsers',
+      getResolver('communityUsers')(getEventRelatedMember(event, payload))
+    ) ?? []
+
+    decoratePayload(payload)
+    ingestInCache(payload)
+
+    const [community] = pullFromCache('community', payload.communities[0].communityId) ?? []
+    const [member] = pullFromCache(
+      'communityUsers',
+      getResolver('communityUsers')(getEventRelatedMember(event, payload))
+    ) ?? []
+
+    if (cachedCommunity && isMatch(cachedCommunity, community) && cachedMember && isMatch(cachedMember, member)) {
+      return
+    }
+
+    callback(community, member)
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}

package/src/community/observers/observeCommunity.ts

@@ -9,6 +9,10 @@ import {
   onCommunityDeleted,
   onCommunityJoined,
   onCommunityLeft,
+  onCommunityUserAdded,
+  onCommunityUserRemoved,
+  onCommunityUserBanned,
+  onCommunityUserUnbanned
 } from '../events'
 
 /**
@@ -27,7 +31,7 @@ import {
  *
  * @category Community Observer
  */
-export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onJoin', 'onLeft']>(
+export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onJoin', 'onLeft', 'onUserAdded', 'onUserRemoved', 'onUserBanned', 'onUserUnbanned']>(
   communityId: string,
   callback: Amity.ObjectListener<Amity.QueryResult<Amity.Community>, Events>
 ): Amity.Unsubscriber => {
@@ -41,9 +45,6 @@ export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelet
     result: Amity.QueryResult<Amity.Community>,
     action: Events[number]
   ) => {
-    // filter function
-    if (result.data?.communityId !== communityId) return
-
     if (callback instanceof Function)
       return callback(result)
 
@@ -53,18 +54,31 @@ export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelet
     callback[action]?.(result)
   }
 
+  const realtimeRouter = (
+    result: Amity.QueryResult<Amity.Community>,
+    action: Events[number]
+  ) => {
+    if (result.data?.communityId !== communityId) return
+
+    router(result, action)
+  }
+
   const disposers: Amity.Unsubscriber[] = []
 
   disposers.push(
-    onCommunityUpdated(data => router({ data }, 'onUpdate')),
-    onCommunityDeleted(data => router({ data }, 'onDelete')),
-    onCommunityJoined(data => router({ data }, 'onJoin')),
-    onCommunityLeft(data => router({ data }, 'onLeft')),
+    onCommunityUpdated(data => realtimeRouter({ data }, 'onUpdate')),
+    onCommunityDeleted(data => realtimeRouter({ data }, 'onDelete')),
+    onCommunityJoined(data => realtimeRouter({ data }, 'onJoin')),
+    onCommunityLeft(data => realtimeRouter({ data }, 'onLeft')),
+    onCommunityUserAdded(data => realtimeRouter({ data }, 'onUserAdded')),
+    onCommunityUserRemoved(data => realtimeRouter({ data }, 'onUserRemoved')),
+    onCommunityUserBanned(data => realtimeRouter({ data }, 'onUserBanned')),
+    onCommunityUserUnbanned(data => realtimeRouter({ data }, 'onUserUnbanned')),
   )
 
   runQuery(
     createQuery(getCommunity, communityId),
-    result => result.data && router(result, 'onFetch')
+    result => router(result, 'onFetch')
   )
 
   return () => {

package/src/core/cache/ingest.ts

@@ -1,6 +1,8 @@
-import { pushToCache } from './push'
+import { pullFromCache } from './pull'
+import { mergeInCache } from './merge'
 
-import { storeInterests } from '../model/idResolvers'
+import { getResolver, storeInterests } from '~/core/model'
+import { pushToCache } from '~/core/cache/push'
 
 /**
  * Ingest a payload (v3) into the cache
@@ -19,6 +21,20 @@ export const ingestInCache = (
       const name = storeInterests[key]
       if (!name) return
 
-      pushToCache(name, ...payload[key])
+      payload[key].forEach(model => {
+        const [cached] = pullFromCache(name, getResolver(name)(model)) ?? []
+
+        if (cached) {
+          // > instead of >= - some updates like reactions do not change updatedAt
+          if (cached.updatedAt && cached.updatedAt > model.updatedAt) {
+            return
+          }
+
+          // personal fields like isJoined, myReactions are missed from real time event payload
+          mergeInCache(name, model)
+        } else {
+          pushToCache(name, model)
+        }
+      })
     })
 }

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/query/paging.ts

@@ -84,6 +84,10 @@ export const toToken = (
         after: paging.after,
         first: paging.limit,
       }
+    } else if (!isNaN(paging?.limit!)) {
+      payload = {
+        last: paging.limit,
+      }
     }
   }
 

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';