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

package/src/follow/api/queryFollowings.ts

@@ -1,4 +1,4 @@
-import { queryFollows } from './utils'
+import { queryFollows } from './utils';
 
 /**
  * ```js
@@ -14,14 +14,11 @@ import { queryFollows } from './utils'
  * @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)
+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
@@ -39,4 +36,4 @@ export const queryFollowings = async (
 queryFollowings.locally = (
   query: Parameters<typeof queryFollowings>[0],
 ): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
-  queryFollows.locally('following', query)
+  queryFollows.locally('following', query);

package/src/follow/api/unfollow.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { fireEvent } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -17,16 +17,18 @@ import { fireEvent } from '~/core/events'
  * @async
  */
 export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('follow/unfollow', userId)
+  const client = getActiveClient();
+  client.log('follow/unfollow', userId);
 
-  const { data } = await client.http.delete<Amity.FollowStatusPayload>(`/api/v4/me/following/${userId}`)
+  const { data } = await client.http.delete<Amity.FollowStatusPayload>(
+    `/api/v4/me/following/${userId}`,
+  );
 
   if (client.cache) {
-    ingestInCache(data)
+    ingestInCache(data);
   }
 
-  fireEvent('follow.unfollowed', data.follows[0])
+  fireEvent('follow.unfollowed', data.follows[0]);
 
-  return true
-}
+  return true;
+};

package/src/follow/api/utils.ts

@@ -1,21 +1,21 @@
-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'
+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
+    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 client = getActiveClient();
+  client.log(`follow/queryF${key.substring(1)}`, query);
 
-  const { userId, page, ...params } = 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}`,
@@ -25,39 +25,44 @@ export const queryFollows = async (
         token: toToken(page, 'skiplimit'),
       },
     },
-  )
+  );
 
-  const { paging, ...payload } = data
-  const { follows } = payload
+  const { paging, ...payload } = data;
+  const { follows } = payload;
 
-  const cachedAt = client.cache && Date.now()
+  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 })
+    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)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  return { data: follows, cachedAt, prevPage, nextPage }
-}
+  return { data: follows, cachedAt, prevPage, nextPage };
+};
 
 queryFollows.locally = (
   key: Parameters<typeof queryFollows>[0],
-  query: Parameters<typeof queryFollows>[1]
+  query: Parameters<typeof queryFollows>[1],
 ): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined => {
-  const client = getActiveClient()
-  client.log(`follow/queryF${key.substring(1)}.locally`, query)
+  const client = getActiveClient();
+  client.log(`follow/queryF${key.substring(1)}.locally`, query);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const { page, ...params } = query
+  const { page, ...params } = query;
 
-  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable]
-  const { data, cachedAt } = pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {}
+  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {};
 
   if (!data?.follows.length) {
     return;
@@ -66,12 +71,12 @@ queryFollows.locally = (
   const follows: Amity.FollowStatus[] = data.follows
     .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
     .filter(Boolean)
-    .map(({ data }) => data)
+    .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous)
-  const nextPage = toPage(data?.paging.next)
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
   return follows.length === data?.follows?.length
     ? { data: follows, cachedAt, prevPage, nextPage }
-    : undefined
-}
+    : undefined;
+};

package/src/follow/events/index.ts

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

package/src/follow/events/onFollowInfoUpdated.ts

@@ -1,5 +1,5 @@
-import { createFollowEventSubscriber } from './utils'
-import { getFollowInfo } from '~/follow/api'
+import { createFollowEventSubscriber } from './utils';
+import { getFollowInfo } from '~/follow/api';
 
 /**
  * ```js
@@ -16,16 +16,18 @@ import { getFollowInfo } from '~/follow/api'
  *
  * @category Follow Events
  */
-export const onFollowInfoUpdated = (callback: Amity.Listener<Amity.FollowInfo>): Amity.Unsubscriber => {
+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)])
+    const [{ data: followInfoFrom }, { data: followInfoTo }] = await Promise.all([
+      getFollowInfo(payload.from),
+      getFollowInfo(payload.to),
+    ]);
 
     callback(followInfoFrom);
-    callback(followInfoTo)
-  }
+    callback(followInfoTo);
+  };
 
   const disposers = [
     createFollowEventSubscriber('follow.created', handler),
@@ -35,9 +37,9 @@ export const onFollowInfoUpdated = (callback: Amity.Listener<Amity.FollowInfo>):
     createFollowEventSubscriber('follow.requestCanceled', handler),
     createFollowEventSubscriber('follow.requestDeclined', handler),
     createFollowEventSubscriber('follow.followerDeleted', handler),
-  ]
+  ];
 
   return () => {
-    disposers.forEach(fn => fn())
-  }
-}
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/events/onFollowRequestAccepted.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -15,5 +15,6 @@ import { createFollowEventSubscriber } from './utils'
  *
  * @category Follow Events
  */
-export const onFollowRequestAccepted = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.accepted', callback)
+export const onFollowRequestAccepted = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.accepted', callback);

package/src/follow/events/onFollowRequestCanceled.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -15,5 +15,6 @@ import { createFollowEventSubscriber } from './utils'
  *
  * @category Follow Events
  */
-export const onFollowRequestCanceled = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.requestCanceled', callback)
+export const onFollowRequestCanceled = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requestCanceled', callback);

package/src/follow/events/onFollowRequestDeclined.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -15,5 +15,6 @@ import { createFollowEventSubscriber } from './utils'
  *
  * @category Follow Events
  */
-export const onFollowRequestDeclined = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.requestDeclined', callback)
+export const onFollowRequestDeclined = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requestDeclined', callback);

package/src/follow/events/onFollowerDeleted.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -15,5 +15,6 @@ import { createFollowEventSubscriber } from './utils'
  *
  * @category Follow Events
  */
-export const onFollowerDeleted = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.followerDeleted', callback)
+export const onFollowerDeleted = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.followerDeleted', callback);

package/src/follow/events/onFollowerRequested.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -15,5 +15,6 @@ import { createFollowEventSubscriber } from './utils'
  *
  * @category Follow Events
  */
-export const onFollowerRequested = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.requested', callback)
+export const onFollowerRequested = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requested', callback);

package/src/follow/events/onUserFollowed.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createFollowEventSubscriber } from './utils'
  * @category Follow Events
  */
 export const onUserFollowed = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.created', callback)
+  createFollowEventSubscriber('follow.created', callback);

package/src/follow/events/onUserUnfollowed.ts

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils'
+import { createFollowEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -15,5 +15,6 @@ import { createFollowEventSubscriber } from './utils'
  *
  * @category Follow Events
  */
-export const onUserUnfollowed = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
-  createFollowEventSubscriber('follow.unfollowed', callback)
+export const onUserUnfollowed = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.unfollowed', callback);

package/src/follow/events/utils.ts

@@ -1,38 +1,33 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { createEventSubscriber } from '~/core/events'
-import { queryCache, upsertInCache } from '~/cache/api'
+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>
+  callback: Amity.Listener<Amity.FollowStatus>,
 ) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.FollowStatus) => {
     if (!client.cache) {
-      callback(payload)
+      callback(payload);
     } else {
-      ingestInCache({ follows: [payload] })
+      ingestInCache({ follows: [payload] });
 
       const queries = [
-        ...queryCache(['followers', 'query']) ?? [],
-        ...queryCache(['followings', 'query']) ?? [],
-      ]
+        ...(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)
+      callback(payload);
     }
-  }
+  };
 
-  return createEventSubscriber(
-    client,
-    event,
-    event,
-    filter
-  )
-}
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/follow/observers/index.ts

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

package/src/follow/observers/observeFollowInfo.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createQuery, runQuery, queryOptions } from '~/core/query'
-import { getFollowInfo } from '../api'
-import { onFollowInfoUpdated } from '../events'
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { getFollowInfo } from '../api';
+import { onFollowInfoUpdated } from '../events';
 
 /**
  * ```js
@@ -22,47 +22,43 @@ import { onFollowInfoUpdated } from '../events'
 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'
+  policy: Amity.QueryPolicy = 'cache_then_server',
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeFollowInfo(tmpid: ${timestamp}) > listen`)
+  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)
+  const router = (result: Amity.Snapshot<Amity.FollowInfo>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
 
-    if (action !== 'onFetch') callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    callback[action]?.(result)
-  }
+    callback[action]?.(result);
+  };
 
-  const realtimeRouter = (
-    result: Amity.Snapshot<Amity.FollowInfo>,
-    action: Events[number]
-  ) => {
-    if (result.data?.userId !== userId) return
+  const realtimeRouter = (result: Amity.Snapshot<Amity.FollowInfo>, action: Events[number]) => {
+    if (result.data?.userId !== userId) return;
 
-    router(result, action)
-  }
+    router(result, action);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onFollowInfoUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
-  )
+    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())
-  }
-}
+    log(`observeFollowInfo(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/observeFollowers.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
 import {
   onFollowerRequested,
@@ -7,8 +7,8 @@ import {
   onFollowRequestCanceled,
   onUserFollowed,
   onUserUnfollowed,
-  onFollowerDeleted
-} from '../events'
+  onFollowerDeleted,
+} from '../events';
 
 /**
  * ```js
@@ -26,40 +26,39 @@ import {
  *
  * @category Follow Observer
  */
-export const observeFollowers = <Events extends [
-  'onRequested',
-  'onAccepted',
-  'onDeclined',
-  'onCanceled',
-  'onFollowed',
-  'onUnfollowed',
-  'onDeleted',
-]>(
+export const observeFollowers = <
+  Events extends [
+    'onRequested',
+    'onAccepted',
+    'onDeclined',
+    'onCanceled',
+    'onFollowed',
+    'onUnfollowed',
+    'onDeleted',
+  ],
+>(
   userId: Amity.User['userId'],
-  callback: Amity.ObjectListener<Amity.FollowStatus, Events>
+  callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeFollowers(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeFollowers(tmpid: ${timestamp}) > listen`);
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    status: Amity.FollowStatus,
-    action: Events[number],
-  ) => {
+  const router = (status: Amity.FollowStatus, action: Events[number]) => {
     if (status.from !== userId) {
       return;
     }
 
     if (callback instanceof Function) {
-      return callback(status)
+      return callback(status);
     }
 
-    callback.onEvent?.(action, status)
-    callback[action]?.(status)
-  }
+    callback.onEvent?.(action, status);
+    callback[action]?.(status);
+  };
 
   disposers.push(
     onFollowerRequested(x => router(x, 'onRequested')),
@@ -69,10 +68,10 @@ export const observeFollowers = <Events extends [
     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())
-  }
-}
+    log(`observeFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};