@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-beta.10

package/src/core/query/query.ts

@@ -1,5 +1,3 @@
-import { syncInCache } from '../cache'
-
 import { isPaged } from './paging'
 
 /**
@@ -44,53 +42,40 @@ export const isOffline = <Args extends any[], Returned extends any>(
 ): func is Amity.OfflineFunc<Args, Returned> => isFetcher(func) || isMutator(func)
 
 /**
- * Type guard to check and cast that a given object has the "syncedAt" property
+ * Type guard to check and cast that a given object has the "cachedAt" property
  *
  * @param model any object to check on
- * @returns success boolean if the object has property "syncedAt"
+ * @returns success boolean if the object has property "cachedAt"
  *
  * @hidden
  */
-export const isSyncable = (model: any): model is Amity.Syncable => (
-  model?.hasOwnProperty('syncedAt')
+export const isCachable = (model: any): model is Amity.Cachable => (
+  model?.hasOwnProperty('cachedAt')
 )
 
 /**
- * Checks if a model is considered local (syncedAt === -1)
+ * Checks if a model is considered local (cachedAt === -1)
  *
- * @param model any syncable object to check
+ * @param model any cachable object to check
  * @returns success boolean if the object is marked as local
  *
  * @hidden
  */
-export const isLocal = (model?: any): model is Amity.Syncable => {
-  return isSyncable(model) && model?.syncedAt === -1
+export const isLocal = (model?: any): model is Amity.Local => {
+  return isCachable(model) && model?.cachedAt === -1
 }
 
 /**
  * Checks if a model is considered fresh
  *
- * @param model any syncable object to check
+ * @param model any cachable object to check
  * @param lifeSpan the supposedly duration for which the object is considered synced
  * @returns success boolean if the object is below the given lifespan
  *
  * @hidden
  */
-export const isFresh = (model?: Amity.Syncable, lifeSpan: number = 0) => {
-  return Date.now() - (model?.syncedAt ?? 0) <= lifeSpan
-}
-
-/**
- * Checks if a model is considered synced
- *
- * @param model any syncable object to check
- * @param lifeSpan the supposedly duration for which the object is considered synced
- * @returns success boolean if the object is local or below the given lifespan
- *
- * @hidden
- */
-export const isSynced = (model?: any, lifeSpan: number = 0) => {
-  return isLocal(model) || isFresh(model, lifeSpan)
+export const isFresh = (model?: Amity.Cachable, lifeSpan: number = 0) => {
+  return Date.now() - (model?.cachedAt ?? 0) <= lifeSpan
 }
 
 /**
@@ -166,45 +151,6 @@ const isEmpty = (local: any) => {
   return false
 }
 
-/**
- * Checks if an unknown shaped payload is considered synced or not.
- * The object will first be identified by 3 types of shapes:
- *
- * 1. Amity.Paged<Amity.Syncable>
- * 2. Amity.Syncable
- * 3. Record<string, Amity.Syncable>
- *
- * then the "Syncable" component will be extracted and evaluated against
- * the query options' lifeSpan value.
- *
- * @param local the unknown object to check for freshness
- * @param options query options (for lifeSpan checking)
- * @returns true if the mixed-shape "local" content is considered fresh
- *
- * @hidden
- */
-const shouldAbort = (local: any, options: Amity.QueryOptions) => {
-  // it's a paged query
-  if (isPaged(local) && shouldAbort(local.data, options)) {
-    return true
-  }
-
-  // if it's object let's try to see if it's Amity.Syncable first
-  else if (isSynced(local, options.lifeSpan)) {
-    return true
-  }
-
-  // otherwise consider as Record<string, Amity.Syncable>
-  else if (
-    Object.values(local).length > 0 &&
-    Object.values(local).every(item => isSynced(item, options.lifeSpan))
-  ) {
-    return true
-  }
-
-  return false
-}
-
 /**
  * ```js
  * import { createQuery, getUser, runQuery } from '@amityco/ts-sdk'
@@ -224,77 +170,79 @@ const shouldAbort = (local: any, options: Amity.QueryOptions) => {
  */
 export const runQuery = <Args extends any[], Returned extends any>(
   { func, args }: Amity.Query<Args, Returned>,
-  callback?: (args: Amity.QueryResult<Returned | undefined>) => void,
+  callback?: (args: Amity.Snapshot<Returned | undefined>) => void,
   options: Amity.QueryOptions = queryOptions('cache_then_server')
 ) => {
-  if (!isOffline(func) || options.lifeSpan === 0) {
-    callback?.(wrap(undefined, {
-      origin: 'server',
-      loading: true
-    }))
-
-    func(...args)
-      .then(fresh => {
-        callback?.(wrap(fresh, {
-          origin: 'server',
+  let local: Returned | undefined
+
+  // offline first
+  if (isOffline(func) && options.lifeSpan !== 0) {
+    try {
+      local = isMutator(func)
+        ? func.optimistically(...args)
+        : func.locally(...args)
+    } catch (error) {
+      callback?.(
+        createSnapshot<Returned>(undefined, {
+          origin: 'local',
           loading: false,
-        }))
-      })
-      .catch(error => {
-        callback?.(wrap(undefined, {
           error,
-          loading: false,
-        }))
-      })
+        })
+      )
+    }
 
-    return
-  }
+    const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan)
 
-  const local = isMutator(func)
-    ? func.optimistically(...args)
-    : func.locally(...args)
+    callback?.(createSnapshot(local , {
+      origin: 'local',
+      loading: !(isFetcher(func) && shouldAbort)
+    }))
 
-  if (!isEmpty(local)) {
-    callback?.(wrap(local, { origin: 'local' }))
+    if (shouldAbort)
+      return
+  } else {
+    callback?.(createSnapshot(undefined, {
+      origin: 'local',
+      loading: true
+    }))
   }
 
-  if (local && isFetcher(func) && shouldAbort(local, options)) return
-
-  callback?.(wrap(local, {
-    origin: 'local',
-    loading: true,
-  }))
-
   func(...args)
     .then(fresh => {
       // @ts-ignore i know.
-      isLocal(local) && syncInCache(local, fresh)
+//      isLocal(local) && syncInCache(local, fresh)
 
-      callback?.(wrap(fresh, {
-        origin: 'server',
-        loading: false
-      }))
+      callback?.(
+        createSnapshot(fresh, {
+          origin: 'server',
+          loading: false,
+        })
+      )
     })
     .catch(error => {
-      callback?.(wrap(local, {
-        error,
-        loading: false,
-      }))
+      callback?.(
+        createSnapshot(undefined, {
+          origin: 'server',
+          loading: false,
+          error,
+        })
+      )
     })
 }
 
 /**
+ * This is a TS hack around types
  *
  * @param data
- * @param meta
- * @returns
+ * @param options
+ *
+ * @category Query API
+ * @hidden
  */
-const wrap = <T extends any>(data: T, meta: Amity.QueryMetadata = {}) => {
-  if (isPaged(data))
-    return {
-      ...meta,
-      ...data as Amity.Paged<T>,
-    } as Amity.QueryResult<T>
+function createSnapshot<T>(data: T | undefined, options?: Amity.SnapshotOptions): Amity.Snapshot<T>;
+function createSnapshot(data: unknown, options?: Amity.SnapshotOptions): unknown {
+  if (isPaged(data) || isCachable(data))
+    return { ...options, ...data }
 
-  return { ...meta, data } as Amity.QueryResult<T>
+  return { ...options, data }
 }

package/src/core/subscription.ts

@@ -1,26 +1,75 @@
 import { getActiveClient } from '~/client/api'
+import { ASCError } from '~/core/errors'
+import { proxyMqttEvents } from '~/core/events'
 
-const markers = {
-  all_and_children: "#",
-  children_only: "+",
+export enum SubscriptionLevels {
+  COMMUNITY = 'community',
+  POST = 'post',
+  COMMENT = 'comment',
+  POST_AND_COMMENT = 'post_and_comment',
+  USER = 'user',
 }
 
-export const getTopic = (
+const getCommunityUserTopic = (
   { path }: Amity.Subscribable,
-  option?: "all_and_children" | "children_only"
-) => `${path}/${option ? markers[option] : ''}`
+  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 function subscribe(topic: string): Amity.Unsubscriber {
-  const client = getActiveClient()
+export const getCommunityTopic = (
+  { path }: Amity.Subscribable,
+  level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
+): string =>
+  getCommunityUserTopic({ path }, level)
 
-  client.mqtt.subscribe(topic, (error, granted) => {
-    if (error) {
-      console.error(`Can not subscribe to ${topic}`, error)
-    } else {
-      console.log('Subscribe granted', granted)
-    }
-  })
+export const getUserTopic = (
+  { path }: Amity.Subscribable,
+  level: Exclude<SubscriptionLevels, SubscriptionLevels.COMMUNITY> = SubscriptionLevels.USER,
+): string =>
+  getCommunityUserTopic({ path }, level)
 
-  return () => client.mqtt.unsubscribe(topic)
-}
+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/mqtt.ts

@@ -1,22 +1,31 @@
-import mqtt, { MqttClient, IClientOptions } from 'mqtt'
+import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from 'mqtt/dist/mqtt'
+import { ASCError, ASCUnknownError } from '~/core/errors'
 
-export function getMqttOptions(params: { username: string, password: string }): IClientOptions {
+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 {
-    keepalive: 30,
+    clean: false, // keep subscriptions
+    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
     protocolId: 'MQTT',
     protocolVersion: 4,
-    clean: true,
-    reconnectPeriod: 1000,
-    connectTimeout: 30 * 1000,
+    reconnectPeriod: 0, // disable auto reconnect
     will: {
       topic: 'WillMsg',
       payload: 'Connection Closed abnormally..!',
       qos: 0,
       retain: false
     },
-    rejectUnauthorized: false,
 
-    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
     ...params
   }
 }
@@ -31,45 +40,102 @@ export function getMqttOptions(params: { username: string, password: string }):
  * @hidden
  */
 export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
-  let mqttClient: 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 }))
 
-    return new Promise(resolve => mqttClient.once('connect', () => resolve()))
+    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()))
+        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)
+      mqttClient?.on(event, handler)
     },
     once<T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) {
-      mqttClient.on(event, handler)
+      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)
+        mqttClient?.off(event, handler)
       } else {
-        mqttClient.removeAllListeners(event)
+        mqttClient?.removeAllListeners(event)
       }
     },
     removeAllListeners() {
-      mqttClient.removeAllListeners()
+      mqttClient?.removeAllListeners()
     },
-    subscribe(topic: string, handler?: (error: Error, granted: Object) => void) {
-      mqttClient.subscribe(topic, { qos: 0 }, handler)
+    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, handler?: (payload: Object) => void) {
-      mqttClient.unsubscribe(topic, handler)
+    unsubscribe(topic: string) {
+      mqttClient?.unsubscribe(topic)
     }
   }
 }

package/src/core/transports/ws.ts

@@ -17,6 +17,7 @@ export const createWebsocketTransport = (endpoint: string) => {
     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()

package/src/feed/api/queryGlobalFeed.ts

@@ -1,8 +1,7 @@
 import { getActiveClient } from '~/client/api/activeClient'
 
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
-import { decoratePayload, toPage, toToken } from '~/core/query'
+import { toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -21,7 +20,7 @@ import { decoratePayload, toPage, toToken } from '~/core/query'
 export const queryGlobalFeed = async (query?: {
   dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[]
   page?: Amity.Page
-}) => {
+}): Promise<Amity.Paged<Amity.Post>> => {
   const client = getActiveClient()
   client.log('feed/queryGlobalFeed', query)
 
@@ -36,15 +35,13 @@ export const queryGlobalFeed = async (query?: {
     } }
   )
 
-  const { paging, ...response } = data
+  const { paging, ...payload } = data
+  const { posts } = payload
 
-  decoratePayload(response as unknown as Record<string, object[]>)
-  ingestInCache(response as unknown as Record<string, object[]>)
-
-  const { posts } = response
+  if (client.cache) ingestInCache(payload as Amity.PostPayload)
 
   const nextPage = toPage(paging.next)
   const prevPage = toPage(paging.previous)
 
-  return { data: toRecord(posts), nextPage, prevPage }
+  return { data: posts, prevPage, nextPage }
 }

package/src/file/api/createFile.ts

@@ -1,7 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
-import { decorateModels } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -20,7 +19,7 @@ import { ingestInCache } from '~/core/cache'
 export const createFile = async <T extends Amity.FileType = any>(
   formData: FormData,
   onProgress?: (percent: number) => void,
-) => {
+): Promise<Amity.Cached<Amity.File>> => {
   const client = getActiveClient()
   client.log('file/createFile', formData)
 
@@ -42,10 +41,13 @@ export const createFile = async <T extends Amity.FileType = any>(
   // API-FIX: payload should be serialized properly
   // const { files } = data
 
-  decorateModels(data)
-  ingestInCache({ files: data })
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache({ files: data }, { cachedAt })
 
-  return data[0]
+  return {
+    data: data[0],
+    cachedAt,
+  }
 }
 
 // TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/deleteFile.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api'
 
-import { dropFromCache } from '~/core/cache'
+import { dropFromCache } from '~/cache/api'
 
 /**
  * ```js
@@ -18,17 +18,16 @@ import { dropFromCache } from '~/core/cache'
  */
 export const deleteFile = async (
   fileId: Amity.File<any>['fileId'],
-) => {
+): Promise<{success: boolean}> => {
   const client = getActiveClient()
   client.log('file/deleteFile', fileId)
 
-    // API-FIX: payload is different than swagger docs!!
-  const { data } = await client.http.delete<{ fileId: string }>(
+  // API-FIX: payload is different than swagger docs!!
+  await client.http.delete<{ fileId: string }>(
     `/api/v3/files/${fileId}`,
   )
 
-  dropFromCache('file', {fileId: data.fileId})
-
+  dropFromCache(['file', 'get', fileId], true)
 
   return { success: true }
 }

package/src/file/api/getFile.ts

@@ -1,7 +1,7 @@
 import { getActiveClient } from '~/client/api'
 
-import { decorateModel } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
+import { pullFromCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
 
 /**
  * ```js
@@ -19,7 +19,7 @@ import { ingestInCache, pullFromCache } from '~/core/cache'
  */
 export const getFile = async <T extends Amity.FileType = any>(
   fileId: Amity.File<any>['fileId'],
-) => {
+): Promise<Amity.Cached<Amity.File>> => {
   const client = getActiveClient()
   client.log('file/getFile', fileId)
 
@@ -30,10 +30,13 @@ export const getFile = async <T extends Amity.FileType = any>(
   // API-FIX: backend bad serializer issue. it should be:
   // const { files } = data
 
-  decorateModel(data)
-  ingestInCache({ files: [data] })
+  const cachedAt = client.cache && Date.now()
+  if (client.cache) ingestInCache({files: [data]}, { cachedAt })
 
-  return data
+  return {
+    data,
+    cachedAt,
+  }
 }
 
 /**
@@ -51,10 +54,19 @@ export const getFile = async <T extends Amity.FileType = any>(
  */
 getFile.locally = (
   fileId: Amity.File<any>['fileId'],
-) => {
+): Amity.Cached<Amity.File> | undefined => {
   const client = getActiveClient()
   client.log('file/getFile.locally', fileId)
 
-  const [file] = pullFromCache('file', fileId) ?? []
-  return file
+  if (!client.cache) return
+
+  const cached = pullFromCache<Amity.File>(['file', 'get', fileId])
+
+  if (!cached)
+    return
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
 }