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

package/dist/post/api/queryPosts.d.ts

@@ -24,7 +24,7 @@ export declare const queryPosts: {
         tags?: Amity.Taggable['tags'];
         matchingOnlyParentPost?: boolean;
         page?: Amity.PageRaw;
-    }): Promise<Amity.Cached<Amity.Paged<Amity.Post>>>;
+    }): Promise<Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>>>;
     /**
      * ```js
      * import { queryPosts } from '@amityco/ts-sdk'
@@ -38,6 +38,6 @@ export declare const queryPosts: {
      *
      * @category Post API
      */
-    locally(query: Parameters<typeof queryPosts>[0]): Amity.Cached<Amity.Paged<Amity.Post>> | undefined;
+    locally(query: Parameters<typeof queryPosts>[0]): Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>> | undefined;
 };
 //# sourceMappingURL=queryPosts.d.ts.map

package/dist/post/api/queryPosts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryPosts.d.ts","sourceRoot":"","sources":["../../../src/post/api/queryPosts.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU;YACd;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,aAAa,GAAG,cAAc,CAAA;QACxE,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC,WAAW,CAAC,CAAA;QACnC,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,QAAQ,CAAC,EAAE,WAAW,GAAG,WAAW,CAAA;QACpC,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC9B,sBAAsB,CAAC,EAAE,OAAO,CAAA;QAChC,IAAI,CAAC,EAAE,MAAM,OAAO,CAAA;KACrB,GACA,QAAQ,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;IAuCjD;;;;;;;;;;;;OAYG;mBAEM,WAAW,iBAAiB,CAAC,CAAC,CAAC,CAAC,GACtC,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,SAAS;CAjBnD,CAAA"}
+{"version":3,"file":"queryPosts.d.ts","sourceRoot":"","sources":["../../../src/post/api/queryPosts.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU;YACd;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,IAAI,CAAC,YAAY,CAAC,CAAC;QACrC,MAAM,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,aAAa,GAAG,cAAc,CAAA;QACxE,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC,WAAW,CAAC,CAAA;QACnC,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,QAAQ,CAAC,EAAE,WAAW,GAAG,WAAW,CAAA;QACpC,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC9B,sBAAsB,CAAC,EAAE,OAAO,CAAA;QAChC,IAAI,CAAC,EAAE,MAAM,OAAO,CAAA;KACrB,GACA,QAAQ,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAuChE;;;;;;;;;;;;OAYG;mBAEM,WAAW,iBAAiB,CAAC,CAAC,CAAC,CAAC,GACtC,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS;CAjBlE,CAAA"}

package/dist/role/api/queryRoles.d.ts

@@ -17,7 +17,7 @@ export declare const queryRoles: {
     (query?: {
         displayName?: string | undefined;
         sortBy?: "displayName" | "firstCreated" | "lastCreated" | undefined;
-        page?: Amity.Page<number> | undefined;
+        page?: Amity.Page | undefined;
     } | undefined): Promise<Amity.Cached<Amity.Paged<Amity.Role>>>;
     /**
      * ```js

package/dist/stream/api/queryStreams.d.ts

@@ -19,7 +19,7 @@ export declare const queryStreams: {
         userPublicIds?: string[] | undefined;
         sortBy?: "lastCreated" | "firstCreated" | undefined;
         isDeleted?: Amity.Stream['isDeleted'];
-        page?: Amity.Page<number> | undefined;
+        page?: Amity.Page | undefined;
     } | undefined): Promise<Amity.Cached<Amity.Paged<Amity.Stream>>>;
     /**
      * ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.15",
+  "version": "0.0.1-beta.16",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

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

@@ -49,7 +49,7 @@ declare global {
      * Minimal CacheEntry alias, used mostly
      */
      type Cached<T extends unknown = unknown> = (
-      T extends Amity.Paged<any>
+      T extends Amity.Paged<any, infer K>
         ? T
         : { data: T }
      ) & {

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

@@ -96,10 +96,21 @@ declare global {
       'user.flagCleared': Amity.UserPayload
     }
 
+    type MqttFollowMessageEvents = {
+      'follow.created': Amity.FollowStatus
+      'follow.requested': Amity.FollowStatus
+      'follow.accepted': Amity.FollowStatus
+      'follow.unfollowed': Amity.FollowStatus
+      'follow.requestCanceled': Amity.FollowStatus
+      'follow.requestDeclined': Amity.FollowStatus
+      'follow.followerDeleted': Amity.FollowStatus
+    }
+
     type MqttMessageEvents = MqttCommunityMessageEvents
       & MqttPostMessageEvents
       & MqttCommentMessageEvents
       & MqttUserMessageEvents
+      & MqttFollowMessageEvents
 
     type Events = WsEvents & MqttEvents & MqttMessageEvents
   }

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

@@ -23,6 +23,9 @@ declare global {
       'comment': Amity.Comment
 
       'stream': Amity.Stream
+
+      'follow': Amity.FollowStatus
+      'followCount': Amity.FollowCount
     }
 
     /**
@@ -48,6 +51,9 @@ declare global {
       'comment': Pick<Amity.Comment, 'commentId'>
 
       'stream': Pick<Amity.Stream, 'streamId'>
+
+      'follow': Pick<Amity.FollowStatus, 'from' | 'to'>
+      'followCount': Pick<Amity.FollowCount, 'userId'>
     }
   }
 }

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

@@ -4,27 +4,27 @@ declare global {
   namespace Amity {
     type PaginationStyles = 'skiplimit' | 'afterbefore' | 'afterbeforeraw'
 
-    type Paging = {
+    type PageLimit = {
       limit: number
     }
 
-    type PrevPage<T extends number | string = number> = Paging & {
+    type PrevPage<T extends number | string> = PageLimit & {
       after?: never
       before?: T
     }
 
-    type NextPage<T extends number | string = number> = Paging & {
+    type NextPage<T extends number | string> = PageLimit & {
       after?: T
       before?: never
     }
 
-    type Page<T extends number | string = number> = (PrevPage<T> | NextPage<T>)
+    type Page = PrevPage<number> | NextPage<number>
 
     /*
       updatedAt is here because if you need sort by updatedAt you
       need to include this data in query also
     */
-    type PageRaw = Page<string> & {
+    type PageRaw = (PrevPage<string> | NextPage<string>) & {
       updatedAt?: string
     }
 
@@ -50,11 +50,11 @@ declare global {
 
     type AfterBeforeRawPagination = PageRaw
 
-    type Pages = {
-      nextPage?: (Page | PageRaw) | null
-      prevPage?: (Page | PageRaw) | null
+    type Pages<T extends (Page | PageRaw)> = {
+      nextPage?: T
+      prevPage?: T
     }
 
-    type Paged<T> = { data: T[] } & Pages
+    type Paged<T, K extends (Page | PageRaw) = Page> = { data: T[] } & Pages<K>
   }
 }

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

@@ -98,5 +98,19 @@ declare global {
     }
 
     type GlobalFeedPayload = Amity.PostPayload
+
+    type FollowersPayload = {
+      follows: Amity.FollowStatus[]
+    }
+    & UserPayload
+
+    type FollowStatusPayload = {
+      follows: Amity.FollowStatus[]
+    }
+
+    type FollowInfoPayload = {
+      follows: Amity.FollowStatus[]
+      followCounts: Amity.FollowCount[]
+    }
   }
 }

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

@@ -47,12 +47,16 @@ declare global {
 
     type Snapshot<T> = (
       T extends Amity.Cached<infer T2>
-        ? T2 extends Amity.Paged<infer T3>
-          ? { data: T3[] | undefined } & Pages & { cachedAt?: CacheOptions['cachedAt'] }
+        ? T2 extends Amity.Paged<infer T3, infer T4>
+          ? { data: T3[] | undefined } & Pages<T4> & { cachedAt?: CacheOptions['cachedAt'] }
           : { data: T2 }  & { cachedAt?: CacheOptions['cachedAt'] }
-        : T extends Amity.Paged<infer T3>
-          ? { data: T3[] | undefined } & Pages
+        : T extends Amity.Paged<infer T3, infer T4>
+          ? { data: T3[] | undefined } & Pages<T4>
           : { data: T | undefined }
     ) & SnapshotOptions
+
+    type RunQueryOptions<T> = T extends Amity.AsyncFunc<infer Args, infer Returned>
+      ? Omit<Amity.Snapshot<Returned>, 'data'>
+      : never
   }
 }

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

@@ -18,7 +18,6 @@ declare global {
 
       apiKey?: string
       userId?: string
-      _internalUserId?: string
       accessToken?: string
 
       use: () => void

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

@@ -0,0 +1,25 @@
+export {}
+
+declare global {
+  namespace Amity {
+    type FollowStatus = {
+      from: Amity.User['userId']
+      to: Amity.User['userId']
+      status: 'pending' | 'accepted' | 'none'
+    }
+    & Amity.CreatedAt
+    & Amity.UpdatedAt
+
+    type FollowCount = {
+      userId: Amity.User['userId']
+      followerCount: number
+      followingCount: number
+      pendingCount: number
+    }
+
+    type FollowInfo = {
+      status?: FollowStatus['status']
+    }
+    & FollowCount
+  }
+}

package/src/@types/index.ts

@@ -13,6 +13,7 @@ import './core/cache' // cache.pull('user', ...)
 import './domains/client' // client definition
 
 import './domains/user'
+import './domains/follow'
 import './domains/file'
 
 import './domains/partials' // small model partials (CreatedAt, etc...)

package/src/channel/api/createChannel.ts

@@ -17,7 +17,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: { type: T, userIds?: Amity.User['userId'] }
+  bundle: { type: T, userIds?: Amity.User['userId'][] }
   & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>
 ): Promise<Amity.Cached<Amity.Channel>> => {
   const client = getActiveClient()

package/src/client/api/activeUser.ts

@@ -0,0 +1,26 @@
+import { ASCError } from '~/core/errors'
+
+let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path'> | null = null
+
+/**
+ * for internal use
+ */
+export const getActiveUser = () => {
+  if (!activeUser) {
+    throw new ASCError(
+      'Connect client first',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.FATAL,
+    )
+  }
+
+  return activeUser!
+}
+
+export const setActiveUser = (user: Amity.User) => {
+  activeUser = {
+    _id: user._id,
+    userId: user.userId,
+    path: user.path,
+  }
+}

package/src/client/api/connectClient.ts

@@ -3,6 +3,7 @@ import { getDeviceId } from '~/core/device'
 import { proxyMqttEvents, proxyWebsocketEvents } from '~/core/events'
 
 import { getActiveClient } from './activeClient'
+import { setActiveUser } from './activeUser'
 
 import { getToken } from './getToken'
 import { onClientBanned } from '../events'
@@ -66,8 +67,9 @@ export const connectClient = async (params: {
   })
 
   client.userId = params.userId
-  client._internalUserId = users[0]._id
   client.accessToken = accessToken
 
+  setActiveUser(users[0])
+
   return client.ws.connected
 }

package/src/community/api/getRecommendedCommunities.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 { getRecommendedCommunities } from '@amityco/ts-sdk'
+ * const communities = await getRecommendedCommunities()
+ * ```
+ *
+ * Gets a list of recommended {@link Amity.Community} objects
+ *
+ * @param query The query parameters
+ * @returns A list of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const getRecommendedCommunities = async (
+  query?: Partial<Amity.PageLimit>
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient()
+  client.log('channel/getRecommendedCommunities', 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/recommended`, { params: { options: { limit }}}
+  )
+
+  const { communities } = data
+
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt })
+
+    const cacheKey = ['community', 'recommended', { params: { options: { limit }} }]
+    pushToCache(cacheKey, { communities: communities.map(getResolver('community')) })
+  }
+
+  return { data: communities, cachedAt }
+}
+
+/**
+ * ```js
+ * import { getRecommendedCommunities } from '@amityco/ts-sdk'
+ * const communities = getRecommendedCommunities.locally()
+ * ```
+ *
+ * Gets a list of recommended {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+getRecommendedCommunities.locally = (
+  query: Parameters<typeof getRecommendedCommunities>[0],
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient()
+  client.log('community/getRecommendedCommunities.locally', query)
+
+  if (!client.cache) return
+
+  const { limit = 5 } = query ?? {}
+
+  const queryKey = ['community', 'recommended', { 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/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/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

@@ -44,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')
@@ -121,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))
@@ -131,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
 }
 
 /**
@@ -157,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))
@@ -167,5 +167,5 @@ export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | null => {
     return json as Amity.PageRaw
   }
 
-  return null
+  return undefined
 }

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/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
+}