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

package/src/follow/api/getFollowInfo.ts

@@ -0,0 +1,75 @@
+import { getActiveClient } from '~/client/api'
+import { pullFromCache, pushToCache } from '~/cache/api'
+
+const getCacheKey = (userId: Amity.User['userId']) => ['followInfo', 'get', `${getActiveClient().userId}#${userId}`]
+
+/**
+ * ```js
+ * import { getFollowInfo } from '@amityco/ts-sdk'
+ * const { data: followInfo } = await getFollowInfo('foobar')
+ * ```
+ *
+ * Fetches the number of followers, followings, pending requests and the follow status for current user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns the associated {@link Amity.FollowInfo} object
+ *
+ * @category Follow API
+ * @async
+ */
+export const getFollowInfo = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.FollowInfo>> => {
+  const client = getActiveClient()
+  client.log('follow/getFollowInfo', userId)
+
+  const { data } = await client.http.get<Amity.FollowInfoPayload>(
+    client.userId === userId ? `/api/v4/me/followInfo` : `/api/v4/users/${userId}/followInfo`,
+  )
+
+  const cachedAt = client.cache && Date.now()
+  const followInfo = {
+    ...data.followCounts[0],
+    status: data.follows?.[0]?.status,
+  }
+
+  if (client.cache) {
+    pushToCache(getCacheKey(userId), followInfo, { cachedAt })
+  }
+
+  return {
+    data: followInfo,
+    cachedAt,
+  }
+}
+
+/**
+ * ```js
+ * import { getFollowInfo } from '@amityco/ts-sdk'
+ * const { data: followInfo } = getFollowInfo.locally('foobar')
+ * ```
+ *
+ * Fetches the number of followers, followings, pending requests and the follow status for current user from cache
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @returns the associated {@link Amity.FollowInfo} object
+ *
+ * @category Follow API
+ */
+getFollowInfo.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.FollowInfo> | undefined => {
+  const client = getActiveClient()
+  client.log('follow/getFollowInfo.locally', userId)
+
+  if (!client.cache) {
+    return
+  }
+
+  const cached = pullFromCache<Amity.FollowInfo>(getCacheKey(userId))
+
+  if (!cached) {
+    return
+  }
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  }
+}

package/src/follow/api/index.ts

@@ -0,0 +1,8 @@
+export * from './queryFollowers'
+export * from './queryFollowings'
+export * from './getFollowInfo'
+
+export * from './follow'
+export * from './unfollow'
+export * from './acceptFollower'
+export * from './declineFollower'

package/src/follow/api/queryFollowers.ts

@@ -0,0 +1,42 @@
+import { queryFollows } from './utils'
+
+/**
+ * ```js
+ * import { queryFollowers } from '@amityco/ts-sdk'
+ * const { data: followers, prevPage, nextPage } = await queryFollowers({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus}
+ *
+ * @param query The query parameters
+ * @returns followers
+ *
+ * @category Follow API
+ * @async
+ */
+export const queryFollowers = async (
+  query: {
+    userId: Amity.User['userId']
+    status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>,
+    page?: Amity.Page
+  }
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> =>
+  queryFollows('followers', query)
+
+/**
+ * ```js
+ * import { queryFollowers } from '@amityco/ts-sdk'
+ * const { data: followers, prevPage, nextPage } = queryFollowers.locally({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus} objects from cache
+ *
+ * @param query The query parameters
+ * @returns followers
+ *
+ * @category Post API
+ */
+queryFollowers.locally = (
+  query: Parameters<typeof queryFollowers>[0],
+): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+  queryFollows.locally('followers', query)

package/src/follow/api/queryFollowings.ts

@@ -0,0 +1,42 @@
+import { queryFollows } from './utils'
+
+/**
+ * ```js
+ * import { queryFollowings } from '@amityco/ts-sdk'
+ * const { data: followings, prevPage, nextPage } = await queryFollowings({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus}
+ *
+ * @param query The query parameters
+ * @returns followings
+ *
+ * @category Follow API
+ * @async
+ */
+export const queryFollowings = async (
+  query: {
+    userId: Amity.User['userId']
+    status?: Exclude<Amity.FollowStatus['status'], 'none'>,
+    page?: Amity.Page
+  }
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> =>
+  queryFollows('following', query)
+
+/**
+ * ```js
+ * import { queryFollowings } from '@amityco/ts-sdk'
+ * const { data: followings, prevPage, nextPage } = queryFollowings.locally({ userId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.FollowStatus} objects from cache
+ *
+ * @param query The query parameters
+ * @returns followings
+ *
+ * @category Post API
+ */
+queryFollowings.locally = (
+  query: Parameters<typeof queryFollowings>[0],
+): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+  queryFollows.locally('following', query)

package/src/follow/api/unfollow.ts

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

package/src/follow/api/utils.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api'
+import { toPage, toToken } from '~/core/query'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache, pushToCache } from '~/cache/api'
+import { getResolver } from '~/core/model'
+
+export const queryFollows = async (
+  key: 'followers' | 'following',
+  query: {
+    userId: Amity.User['userId']
+    status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>,
+    page?: Amity.Page
+  },
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => {
+  const client = getActiveClient()
+  client.log(`follow/queryF${key.substring(1)}`, query)
+
+  const { userId, page, ...params } = query
+
+  const { data } = await client.http.get<Amity.FollowersPayload & Amity.Pagination>(
+    client.userId === userId ? `/api/v4/me/${key}` : `/api/v4/users/${userId}/${key}`,
+    {
+      params: {
+        ...params,
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  )
+
+  const { paging, ...payload } = data
+  const { follows } = payload
+
+  const cachedAt = client.cache && Date.now()
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.FollowersPayload, { cachedAt })
+
+    const cacheKey = [key, 'query', { ...params, userId, options: { ...page } } as Amity.Serializable]
+    pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging })
+  }
+
+  const nextPage = toPage(paging.next)
+  const prevPage = toPage(paging.previous)
+
+  return { data: follows, cachedAt, prevPage, nextPage }
+}
+
+queryFollows.locally = (
+  key: Parameters<typeof queryFollows>[0],
+  query: Parameters<typeof queryFollows>[1]
+): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined => {
+  const client = getActiveClient()
+  client.log(`follow/queryF${key.substring(1)}.locally`, query)
+
+  if (!client.cache) return
+
+  const { page, ...params } = query
+
+  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable]
+  const { data, cachedAt } = pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {}
+
+  if (!data?.follows.length) {
+    return;
+  }
+
+  const follows: Amity.FollowStatus[] = data.follows
+    .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+    .filter(Boolean)
+    .map(({ data }) => data)
+
+  const prevPage = toPage(data?.paging.previous)
+  const nextPage = toPage(data?.paging.next)
+
+  return follows.length === data?.follows?.length
+    ? { data: follows, cachedAt, prevPage, nextPage }
+    : undefined
+}

package/src/follow/events/index.ts

@@ -0,0 +1,10 @@
+export * from './onUserFollowed'
+export * from './onUserUnfollowed'
+export * from './onFollowerDeleted'
+
+export * from './onFollowerRequested'
+export * from './onFollowRequestCanceled'
+export * from './onFollowRequestAccepted'
+export * from './onFollowRequestDeclined'
+
+export * from './onFollowInfoUpdated'

package/src/follow/events/onFollowInfoUpdated.ts

@@ -0,0 +1,43 @@
+import { createFollowEventSubscriber } from './utils'
+import { getFollowInfo } from '~/follow/api'
+
+/**
+ * ```js
+ * import { onFollowInfoUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFollowInfoUpdated(followInfo => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.FollowInfo} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowInfoUpdated = (callback: Amity.Listener<Amity.FollowInfo>): Amity.Unsubscriber => {
+  const handler = async (payload: Amity.FollowStatus) => {
+    const [
+      { data: followInfoFrom },
+      { data: followInfoTo },
+    ] = await Promise.all([getFollowInfo(payload.from), getFollowInfo(payload.to)])
+
+    callback(followInfoFrom);
+    callback(followInfoTo)
+  }
+
+  const disposers = [
+    createFollowEventSubscriber('follow.created', handler),
+    createFollowEventSubscriber('follow.requested', handler),
+    createFollowEventSubscriber('follow.accepted', handler),
+    createFollowEventSubscriber('follow.unfollowed', handler),
+    createFollowEventSubscriber('follow.requestCanceled', handler),
+    createFollowEventSubscriber('follow.requestDeclined', handler),
+    createFollowEventSubscriber('follow.followerDeleted', handler),
+  ]
+
+  return () => {
+    disposers.forEach(fn => fn())
+  }
+}

package/src/follow/events/onFollowRequestAccepted.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onFollowRequestAccepted } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestAccepted(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been accepted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestAccepted = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.accepted', callback)

package/src/follow/events/onFollowRequestCanceled.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onFollowRequestCanceled } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestCanceled(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been canceled
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestCanceled = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.requestCanceled', callback)

package/src/follow/events/onFollowRequestDeclined.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onFollowRequestDeclined } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestDeclined(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been declined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestDeclined = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.requestDeclined', callback)

package/src/follow/events/onFollowerDeleted.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onFollowerDeleted } from '@amityco/ts-sdk'
+ * const dispose = onFollowerDeleted(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follower has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowerDeleted = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.followerDeleted', callback)

package/src/follow/events/onFollowerRequested.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onFollowerRequested } from '@amityco/ts-sdk'
+ * const dispose = onFollowerRequested(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user follows another users and confirmation is required
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowerRequested = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.requested', callback)

package/src/follow/events/onUserFollowed.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onUserFollowed } from '@amityco/ts-sdk'
+ * const dispose = onUserFollowed(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user follows another users and confirmation is not required
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onUserFollowed = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.created', callback)

package/src/follow/events/onUserUnfollowed.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils'
+
+/**
+ * ```js
+ * import { onUserUnfollowed } from '@amityco/ts-sdk'
+ * const dispose = onUserFollowed(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user unfollows
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onUserUnfollowed = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.unfollowed', callback)

package/src/follow/events/utils.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api'
+import { ingestInCache } from '~/cache/api/ingestInCache'
+import { createEventSubscriber } from '~/core/events'
+import { queryCache, upsertInCache } from '~/cache/api'
+
+export const createFollowEventSubscriber = (
+  event: keyof Amity.MqttFollowMessageEvents,
+  callback: Amity.Listener<Amity.FollowStatus>
+) => {
+  const client = getActiveClient()
+
+  const filter = (payload: Amity.FollowStatus) => {
+    if (!client.cache) {
+      callback(payload)
+    } else {
+      ingestInCache({ follows: [payload] })
+
+      const queries = [
+        ...queryCache(['followers', 'query']) ?? [],
+        ...queryCache(['followings', 'query']) ?? [],
+      ]
+
+      queries
+        // @ts-ignore
+        .filter(({ key }) => key[2].userId === payload.from || key[2].userId === payload.to)
+        .forEach(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
+
+      callback(payload)
+    }
+  }
+
+  return createEventSubscriber(
+    client,
+    event,
+    event,
+    filter
+  )
+}

package/src/follow/observers/index.ts

@@ -0,0 +1,3 @@
+export * from './observeFollowInfo'
+export * from './observeFollowers'
+export * from './observeFollowings'

package/src/follow/observers/observeFollowInfo.ts

@@ -0,0 +1,68 @@
+import { getActiveClient } from '~/client/api'
+import { createQuery, runQuery, queryOptions } from '~/core/query'
+import { getFollowInfo } from '../api'
+import { onFollowInfoUpdated } from '../events'
+
+/**
+ * ```js
+ * import { observeFollowInfo } from '@amityco/ts-sdk'
+ *
+ * let followInfo = {}
+ * const dispose = observeFollowInfo(userId, updated => followInfo = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.FollowInfo}
+ *
+ * @param userId the ID of the user to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the post
+ *
+ * @category Follow Observer
+ */
+export const observeFollowInfo = <Events extends ['onFetch', 'onUpdate']>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.FollowInfo>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server'
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeFollowInfo(tmpid: ${timestamp}) > listen`)
+
+  const router = (
+    result: Amity.Snapshot<Amity.FollowInfo>,
+    action: Events[number]
+  ) => {
+    if (callback instanceof Function) return callback(result)
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result)
+
+    callback[action]?.(result)
+  }
+
+  const realtimeRouter = (
+    result: Amity.Snapshot<Amity.FollowInfo>,
+    action: Events[number]
+  ) => {
+    if (result.data?.userId !== userId) return
+
+    router(result, action)
+  }
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  disposers.push(
+    onFollowInfoUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+  )
+
+  runQuery(
+    createQuery(getFollowInfo, userId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  )
+
+  return () => {
+    log(`observeFollowInfo(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}

package/src/follow/observers/observeFollowers.ts

@@ -0,0 +1,78 @@
+import { getActiveClient } from '~/client/api'
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted
+} from '../events'
+
+/**
+ * ```js
+ * import { observeFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = observeFollowers('userId', follower => merge(followers, follower))
+ * ```
+ *
+ * Observe all mutations on a list of followers {@link Amity.FollowStatus} for a given user
+ *
+ * @param userId the ID of the {@link Amity.User}
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Follow Observer
+ */
+export const observeFollowers = <Events extends [
+  'onRequested',
+  'onAccepted',
+  'onDeclined',
+  'onCanceled',
+  'onFollowed',
+  'onUnfollowed',
+  'onDeleted',
+]>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.FollowStatus, Events>
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient()
+
+  const timestamp = Date.now()
+  log(`observeFollowers(tmpid: ${timestamp}) > listen`)
+
+  const disposers: Amity.Unsubscriber[] = []
+
+  const router = (
+    status: Amity.FollowStatus,
+    action: Events[number],
+  ) => {
+    if (status.from !== userId) {
+      return;
+    }
+
+    if (callback instanceof Function) {
+      return callback(status)
+    }
+
+    callback.onEvent?.(action, status)
+    callback[action]?.(status)
+  }
+
+  disposers.push(
+    onFollowerRequested(x => router(x, 'onRequested')),
+    onFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onFollowRequestCanceled(x => router(x, 'onCanceled')),
+    onUserFollowed(x => router(x, 'onFollowed')),
+    onUserUnfollowed(x => router(x, 'onUnfollowed')),
+    onFollowerDeleted(x => router(x, 'onDeleted')),
+  )
+
+  return () => {
+    log(`observeFollowers(tmpid: ${timestamp}) > dispose`)
+    disposers.forEach(fn => fn())
+  }
+}