@amityco/ts-sdk 0.0.1-beta.13 → 0.0.1-beta.16

package/src/community/api/getTopTrendingCommunities.ts

@@ -0,0 +1,86 @@
+import { getActiveClient } from '~/client/api'
+
+import { getResolver } from '~/core/model'
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+
+/**
+ * ```js
+ * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
+ * const trendingCommunities = await getTopTrendingCommunities()
+ * ```
+ *
+ * Gets a list of top trending {@link Amity.Community} objects
+ *
+ * @param query The query parameters
+ * @returns A list of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const getTopTrendingCommunities = async (
+  query?: Partial<Amity.PageLimit>
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient()
+  client.log('channel/getTopTrendingCommunities', query)
+
+  const { limit = 5 } = query ?? {}
+
+  // API-FIX: backend doesnt answer Amity.Response
+  // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
+  const { data } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/top-trending`, { params: { options: { limit }}}
+  )
+
+  const { communities } = data
+
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt })
+
+    const cacheKey = ['community', 'top-trending', { params: { options: { limit }} }]
+    pushToCache(cacheKey, { communities: communities.map(getResolver('community')) })
+  }
+
+  return { data: communities, cachedAt }
+}
+
+/**
+ * ```js
+ * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
+ * const communities = getTopTrendingCommunities.locally()
+ * ```
+ *
+ * Gets a list of top trending {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+getTopTrendingCommunities.locally = (
+  query: Parameters<typeof getTopTrendingCommunities>[0],
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient()
+  client.log('community/getTopTrendingCommunities.locally', query)
+
+  if (!client.cache) return
+
+  const { limit = 5 } = query ?? {}
+
+  const queryKey = ['community', 'top-trending', { params: { options: { limit }} }];
+  const { data, cachedAt } = pullFromCache<{communities: Pick<Amity.Community, 'communityId'>[]}>(queryKey) ?? {}
+
+  if (!data?.communities.length)
+    return
+
+  const communities: Amity.Community[] = data.communities
+    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
+
+  return communities.length === data?.communities?.length
+    ? { data: communities, cachedAt }
+    : undefined
+}

package/src/community/api/index.ts

@@ -15,3 +15,6 @@ export * from './removeCommunityMembers'
 
 export * from './addCommunityMembersRole'
 export * from './removeCommunityMembersRole'
+
+export * from './getTopTrendingCommunities'
+export * from './getRecommendedCommunities'

package/src/community/api/queryCommunityMembers.ts

@@ -51,7 +51,7 @@ export const queryCommunityMembers = async (query: {
   const nextPage = toPage(paging.next)
   const prevPage = toPage(paging.previous)
 
-  return { data: communityUsers, nextPage, prevPage }
+  return { data: communityUsers, cachedAt, nextPage, prevPage }
 }
 
 /**

package/src/core/debug.ts

@@ -1,5 +1,7 @@
 import debug from 'debug'
 
+import { isProduction } from '~/utils/env'
+
 /**
  * Creates a pre-configured logger instance
  *
@@ -12,7 +14,7 @@ import debug from 'debug'
 export const createLogger = (session?: string) => {
   const active = (
       `${session?.trim()}`.length > 0
-    && process?.env?.NODE_ENV !== 'production'
+    && !isProduction
   )
 
   const logger = debug(session!)

package/src/core/device.ts

@@ -1,5 +1,6 @@
 // TODO: find a way to uniquely identify the device
 // import { getStorage } from './storage'
+import { safeProcess } from '~/utils/env'
 
 /** @hidden */
 const VERSION = '11.0.0'
@@ -16,8 +17,8 @@ export const getDeviceId = () => {
 
 /** @hidden */
 export const getDeviceModel = () => {
-  if (process?.versions?.node)
-    return process.versions.node
+  if (safeProcess.versions?.node)
+    return safeProcess.versions.node
 
   if (navigator)
     return `${navigator.product.toLowerCase()}#${navigator.userAgent ?? 'unknown_agent'}`

package/src/core/events.ts

@@ -2,6 +2,8 @@ import mitt from 'mitt'
 
 import { getActiveClient } from '~/client/api/activeClient'
 
+import { scheduleTask } from './microtasks'
+
 // need to sync up the list
 const WS_EVENTS = [
   'disconnected',
@@ -134,5 +136,5 @@ export const fireEvent = <T extends keyof Amity.Events>(
   payload: Amity.Events[T],
 ) => {
   const { emitter } = getActiveClient()
-  setTimeout(() => { emitter.emit(event, payload) }, 0)
+  scheduleTask(() => { emitter.emit(event, payload) })
 }

package/src/core/microtasks.ts

@@ -0,0 +1,27 @@
+let tasks: Function[] = []
+let timer: NodeJS.Timeout
+
+/**
+ * Add a function to run just before the next tick
+ *
+ * @param task function to schedule for later execution
+ */
+export const scheduleTask = (task: Function) => {
+  clearTimeout(timer)
+  tasks.push(task)
+
+  timer = setTimeout(() => {
+    tasks.forEach(fn => fn())
+    tasks = []
+  }, 0)
+}
+
+/**
+ * Cancel the scheduling operation
+ *
+ * @param task function to be removed from later execution
+ */
+export const cancelTask = (task: Function) => {
+  tasks = tasks.filter(fn => fn !== task)
+  if (!tasks.length) clearTimeout(timer)
+}

package/src/core/model/idResolvers.ts

@@ -24,6 +24,9 @@ const idResolvers: Resolvers = {
   comment: ({ commentId }) => commentId,
 
   stream: ({ streamId }) => streamId,
+
+  follow: ({ from, to }) => `${from}#${to}`,
+  followCount: ({ userId }) => userId,
 }
 
 /**

package/src/core/model/identifyModel.ts

@@ -31,6 +31,8 @@ const CRITERIAS: Criterias  = {
   post: ['postId', 'feedId'],
   comment: ['commentId', 'referenceId'],
   stream: ['streamId'],
+  follow: ['from', 'to'],
+  followCount: ['userId', 'followerCount']
 }
 
 /** @hidden */

package/src/core/model/index.ts

@@ -20,4 +20,7 @@ export * from './identifyModel'
   postChildren: 'post',
   comments: 'comment',
   videoStreamings: 'stream',
+
+  follows: 'follow',
+  followCounts: 'followCount'
 }

package/src/core/query/paging.ts

@@ -1,4 +1,3 @@
-// @ts-ignore
 import { encode, decode } from 'js-base64'
 
 /**
@@ -22,7 +21,7 @@ export const isSkipLimit = (json: Object): json is Amity.SkipLimitPagination =>
  * @hidden
  */
 export const isAfterBefore = (json: Object): json is Amity.AfterBeforePagination => (
-  ['after', 'before', 'first', 'last'].some(prop => prop in json)
+  ['after', 'before', 'first', 'last', 'limit'].some(prop => prop in json)
 )
 
 /**
@@ -34,7 +33,7 @@ export const isAfterBefore = (json: Object): json is Amity.AfterBeforePagination
  * @hidden
  */
 export const isAfterBeforeRaw = (json: Object): json is Amity.AfterBeforeRawPagination => (
-  ['after', 'before'].some(prop => prop in json)
+  'limit' in json
 )
 
 /**
@@ -45,7 +44,7 @@ export const isAfterBeforeRaw = (json: Object): json is Amity.AfterBeforeRawPagi
  *
  * @hidden
  */
-export const isPaged = <T extends unknown>(payload: any): payload is Amity.Paged<T> => {
+export const isPaged = <T extends unknown>(payload: any): payload is Amity.Paged<T, any> => {
   return (
      payload?.hasOwnProperty('data')
   && payload?.hasOwnProperty('nextPage')
@@ -63,9 +62,8 @@ export const isPaged = <T extends unknown>(payload: any): payload is Amity.Paged
  * @hidden
  */
 export const toToken = (
-  paging: Amity.Page | undefined,
-  style: 'skiplimit' | 'afterbefore' | 'afterbeforeraw',
-
+  paging: Amity.Page | Amity.PageRaw | undefined,
+  style: Amity.PaginationStyles,
 ): Amity.Token | undefined => {
   if (!paging || !Object.keys(paging).length)
     return
@@ -79,7 +77,7 @@ export const toToken = (
       limit: paging.limit,
     }
   }
-  else if (style === 'afterbefore') {
+  else if (style === 'afterbefore' && isAfterBefore(paging)) {
     /*
       Caution: this testing style is only valid because
       our backend expects nothing else than a number as
@@ -114,6 +112,7 @@ export const toToken = (
   return encode(JSON.stringify(payload))
 }
 
+
 /**
  * Converts a b64 string token into a paging object
  *
@@ -122,8 +121,8 @@ export const toToken = (
  *
  * @hidden
  */
-export const toPage = (token?: Amity.Token): Amity.Page | null => {
-  if (!token) return null
+export const toPage = (token?: Amity.Token): Amity.Page | undefined => {
+  if (!token) return undefined
 
   // don't try catch, let it throw
   const json = JSON.parse(decode(token))
@@ -132,22 +131,22 @@ export const toPage = (token?: Amity.Token): Amity.Page | null => {
     return {
       after: json.skip,
       limit: json.limit!,
-    } as Amity.NextPage
+    } as Amity.NextPage<number>
   } else if (isAfterBefore(json)) {
     if ('before' in json) {
       return {
         before: json.before,
         limit: json.last,
-      } as Amity.PrevPage
+      } as Amity.PrevPage<number>
     } else if ('after' in json) {
       return {
         after: json.after,
         limit: json.first,
-      } as Amity.NextPage
+      } as Amity.NextPage<number>
     }
   }
 
-  return null
+  return undefined
 }
 
 /**
@@ -158,8 +157,8 @@ export const toPage = (token?: Amity.Token): Amity.Page | null => {
  *
  * @hidden
  */
-export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | null => {
-  if (!token) return null
+export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | undefined => {
+  if (!token) return undefined
 
   // don't try catch, let it throw
   const json = JSON.parse(decode(token))
@@ -168,39 +167,5 @@ export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | null => {
     return json as Amity.PageRaw
   }
 
-  return null
-}
-
-/**
- * Slices a collection according to its paging
- *
- * @param type the type of collection (for unique id identification with after/before)
- * @param collection the collection to slice
- * @param paging the paging object
- * @returns the sliced collection according to the paging definition
- *
- * @hidden
- */
-export const sliceByPaging = <K extends Amity.Domain, T extends Amity.Model[K]>(
-  type: K, collection: T[], page?: Amity.Page
-) => {
-  console.log('slice by paging', page)
-  if (!page) return collection.slice()
-
-  let start: number | undefined = 0
-  let end: number | undefined = undefined
-
-  // next page behavior
-  if (page.after) {
-    start = page.after
-    end = start + page.limit
-  // prev page behavior
-  } else if (page.before) {
-    end = page.before + 1
-    start = end > page.limit ? end - page.limit : 0
-  }
-
-  const paged = collection.slice(start, end)
-
-  return paged.length === page.limit ? paged : undefined
+  return undefined
 }

package/src/core/query/query.ts

@@ -170,7 +170,7 @@ const isEmpty = (local: any) => {
  */
 export const runQuery = <Args extends any[], Returned extends any>(
   { func, args }: Amity.Query<Args, Returned>,
-  callback?: (args: Amity.Snapshot<Returned | undefined>) => void,
+  callback?: (args: Amity.Snapshot<Returned>) => void,
   options: Amity.QueryOptions = queryOptions('cache_then_server')
 ) => {
   let local: Returned | undefined
@@ -193,7 +193,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
 
     const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan)
 
-    callback?.(createSnapshot(local , {
+    callback?.(createSnapshot<Returned>(local , {
       origin: 'local',
       loading: !(isFetcher(func) && shouldAbort)
     }))
@@ -201,7 +201,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
     if (shouldAbort)
       return
   } else {
-    callback?.(createSnapshot(undefined, {
+    callback?.(createSnapshot<Returned>(undefined, {
       origin: 'local',
       loading: true
     }))
@@ -213,7 +213,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
 //      isLocal(local) && syncInCache(local, fresh)
 
       callback?.(
-        createSnapshot(fresh, {
+        createSnapshot<Returned>(fresh, {
           origin: 'server',
           loading: false,
         })
@@ -221,7 +221,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
     })
     .catch(error => {
       callback?.(
-        createSnapshot(undefined, {
+        createSnapshot<Returned>(undefined, {
           origin: 'server',
           loading: false,
           error,

package/src/core/subscription.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api'
 import { ASCError } from '~/core/errors'
 import { proxyMqttEvents } from '~/core/events'
+import { getActiveUser } from '~/client/api/activeUser'
 
 export enum SubscriptionLevels {
   COMMUNITY = 'community',
@@ -54,6 +55,22 @@ export const getCommentTopic = ({ path }: Amity.Subscribable): string => {
   return path;
 };
 
+export const getMyFollowersTopic = (): string => {
+  const user = getActiveUser()
+
+  const [networkId] = user.path.split('/user/');
+
+  return `${networkId}/membership/${user._id}/+/+`;
+}
+
+export const getMyFollowingsTopic = (): string => {
+  const user = getActiveUser()
+
+  const [networkId] = user.path.split('/user/');
+
+  return `${networkId}/membership/+/${user._id}/+`;
+}
+
 let mqttAccessToken: string;
 let mqttUserId: string;
 
@@ -61,11 +78,12 @@ export function subscribeTopic(
   topic: string,
   callback?: Amity.Listener<ASCError | void>
 ): Amity.Unsubscriber {
-  const { mqtt, emitter, accessToken, _internalUserId } = getActiveClient()
+  const { mqtt, emitter, accessToken } = getActiveClient()
+  const user = getActiveUser();
 
-  if (mqttAccessToken !== accessToken || mqttUserId !== _internalUserId) {
+  if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
     mqttAccessToken = accessToken!
-    mqttUserId = _internalUserId!
+    mqttUserId = user._id!
 
     mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId })
     proxyMqttEvents(mqtt, emitter)

package/src/feed/api/queryGlobalFeed.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api/activeClient'
 
 import { toPage, toToken } from '~/core/query'
 import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { getResolver } from '~/core/model'
 
 /**
  * ```js
@@ -19,15 +21,16 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  **/
 export const queryGlobalFeed = async (query?: {
   dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[]
+  useCustomRanking?: boolean
   page?: Amity.Page
-}): Promise<Amity.Paged<Amity.Post>> => {
+}): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
   const client = getActiveClient()
   client.log('feed/queryGlobalFeed', query)
 
-  const { page, ...params } = query ?? {}
+  const { useCustomRanking, page, ...params } = query ?? {}
 
   const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    `/api/v4/me/global-feeds`, { params: {
+    useCustomRanking ? `/api/v5/me/global-feeds` : `/api/v4/me/global-feeds`, { params: {
       ...params,
       options: {
         token: toToken(page, 'skiplimit')
@@ -38,10 +41,60 @@ export const queryGlobalFeed = async (query?: {
   const { paging, ...payload } = data
   const { posts } = payload
 
-  if (client.cache) ingestInCache(payload as Amity.PostPayload)
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.PostPayload)
+
+    const cacheKey = ['globalFeed', 'query', { ...params, useCustomRanking, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging })
+  }
 
   const nextPage = toPage(paging.next)
   const prevPage = toPage(paging.previous)
 
-  return { data: posts, prevPage, nextPage }
+  return { data: posts, cachedAt, prevPage, nextPage }
+}
+
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk'
+ * const posts = await queryGlobalFeed.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ **/
+queryGlobalFeed.locally = (
+  query: Parameters<typeof queryGlobalFeed>[0],
+): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
+  const client = getActiveClient()
+  client.log('post/queryGlobalFeed.locally', query)
+
+  if (!client.cache) return
+
+  const { useCustomRanking, page, ...params } = query ?? {}
+
+  const queryKey = ['globalFeed', 'query', { ...params, useCustomRanking, options: { ...page }} as Amity.Serializable];
+  const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {}
+
+  if (!data?.posts.length)
+    return
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
+
+  const prevPage = toPage(data?.paging.previous)
+  const nextPage = toPage(data?.paging.next)
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined
 }

package/src/follow/api/acceptFollower.ts

@@ -0,0 +1,32 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { acceptFollower } from '@amityco/ts-sdk'
+ * await acceptFollower('foobar')
+ * ```
+ *
+ * Accept the follow request
+ *
+ * @param userId the ID of the {@link Amity.User} follower
+ * @returns A success boolean if the follow request was accepted
+ *
+ * @category Follow API
+ * @async
+ */
+export const acceptFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('follow/acceptFollower', userId)
+
+  const { data } = await client.http.post<Amity.FollowStatusPayload>(`/api/v4/me/followers/${userId}`)
+
+  if (client.cache) {
+    ingestInCache(data)
+  }
+
+  fireEvent('follow.accepted', data.follows[0])
+
+  return true
+}

package/src/follow/api/declineFollower.ts

@@ -0,0 +1,32 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { declineFollower } from '@amityco/ts-sdk'
+ * await declineFollower('foobar')
+ * ```
+ *
+ * Decline the follow request or delete the follower
+ *
+ * @param userId the ID of the {@link Amity.User} follower
+ * @returns A success boolean if the follow request was decline
+ *
+ * @category Follow API
+ * @async
+ */
+export const declineFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient()
+  client.log('follow/declineFollower', userId)
+
+  const { data } = await client.http.delete<{ follows: Amity.FollowStatus[] }>(`/api/v4/me/followers/${userId}`)
+
+  if (client.cache) {
+    ingestInCache(data)
+  }
+
+  fireEvent('follow.requestDeclined', data.follows[0])
+
+  return true
+}

package/src/follow/api/follow.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { fireEvent } from '~/core/events'
+
+/**
+ * ```js
+ * import { follow } from '@amityco/ts-sdk'
+ * const status = await follow('foobar')
+ * ```
+ *
+ * Follow the user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns the status {@link Amity.FollowStatus}
+ *
+ * @category Follow API
+ * @async
+ */
+export const follow = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.FollowStatus>> => {
+  const client = getActiveClient()
+  client.log('follow/follow', userId)
+
+  const { data } = await client.http.post<Amity.FollowStatusPayload>(`/api/v4/me/following/${userId}`)
+
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt })
+  }
+
+  fireEvent(
+    data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested',
+    data.follows[0],
+  )
+
+  return {
+    data: data.follows[0],
+    cachedAt,
+  }
+}