@amityco/ts-sdk 0.0.1-beta.25 → 0.0.1-beta.28

package/src/follow/api/follow.ts

@@ -32,10 +32,7 @@ export const follow = async (
     ingestInCache(data, { cachedAt });
   }
 
-  fireEvent(
-    data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested',
-    data.follows[0],
-  );
+  fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
 
   return {
     data: data.follows[0],

package/src/follow/api/getFollowInfo.ts

@@ -27,15 +27,18 @@ export const getFollowInfo = async (
   const client = getActiveClient();
   client.log('follow/getFollowInfo', userId);
 
-  const { data } = await client.http.get<Amity.FollowInfoPayload>(
+  const { data } = await client.http.get<Amity.FollowInfoMePayload | 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,
-  };
+  const followInfo =
+    'follows' in data
+      ? {
+          ...data.followCounts[0],
+          status: data.follows?.[0]?.status,
+        }
+      : data.followCounts[0];
 
   if (client.cache) {
     pushToCache(getCacheKey(userId), followInfo, { cachedAt });

package/src/follow/api/queryFollowers.ts

@@ -14,11 +14,10 @@ import { queryFollows } from './utils';
  * @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);
+export const queryFollowers = async (
+  query: Amity.QueryFollowers,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('followers', query);
 
 /**
  * ```js
@@ -35,5 +34,5 @@ export const queryFollowers = async (query: {
  */
 queryFollowers.locally = (
   query: Parameters<typeof queryFollowers>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('followers', query);

package/src/follow/api/queryFollowings.ts

@@ -14,11 +14,10 @@ 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: Amity.QueryFollowings,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('following', query);
 
 /**
  * ```js
@@ -35,5 +34,5 @@ export const queryFollowings = async (query: {
  */
 queryFollowings.locally = (
   query: Parameters<typeof queryFollowings>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('following', query);

package/src/follow/api/unfollow.ts

@@ -28,7 +28,7 @@ export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> =
     ingestInCache(data);
   }
 
-  fireEvent('follow.unfollowed', data.follows[0]);
+  fireEvent('follow.unfollowed', data);
 
   return true;
 };

package/src/follow/api/utils.ts

@@ -1,5 +1,5 @@
 import { getActiveClient } from '~/client/api';
-import { toPage, toToken } from '~/core/query';
+import { toPageRaw, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
@@ -8,10 +8,10 @@ export const queryFollows = async (
   key: 'followers' | 'following',
   query: {
     userId: Amity.User['userId'];
-    status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>;
-    page?: Amity.Page;
+    status?: Exclude<Amity.FollowStatusType, 'none'>;
+    page?: Amity.PageRaw;
   },
-): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> => {
   const client = getActiveClient();
   client.log(`follow/queryF${key.substring(1)}`, query);
 
@@ -22,7 +22,7 @@ export const queryFollows = async (
     {
       params: {
         ...params,
-        token: toToken(page, 'skiplimit'),
+        token: toToken(page, 'afterbeforeraw'),
       },
     },
   );
@@ -36,15 +36,15 @@ export const queryFollows = async (
     ingestInCache(payload as Amity.FollowersPayload, { cachedAt });
 
     const cacheKey = [
-      key,
+      'follow',
       'query',
-      { ...params, userId, options: { ...page } } as Amity.Serializable,
+      { ...params, userId, options: { ...page }, type: key } as Amity.Serializable,
     ];
     pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: follows, cachedAt, prevPage, nextPage };
 };
@@ -52,7 +52,7 @@ export const queryFollows = async (
 queryFollows.locally = (
   key: Parameters<typeof queryFollows>[0],
   query: Parameters<typeof queryFollows>[1],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined => {
   const client = getActiveClient();
   client.log(`follow/queryF${key.substring(1)}.locally`, query);
 
@@ -60,7 +60,11 @@ queryFollows.locally = (
 
   const { page, ...params } = query;
 
-  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = [
+    'follow',
+    'query',
+    { ...params, options: { ...page }, type: key } as Amity.Serializable,
+  ];
   const { data, cachedAt } =
     pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {};
 
@@ -73,8 +77,8 @@ queryFollows.locally = (
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
 
   return follows.length === data?.follows?.length
     ? { data: follows, cachedAt, prevPage, nextPage }

package/src/follow/events/utils.ts

@@ -9,11 +9,11 @@ export const createFollowEventSubscriber = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.FollowStatus) => {
+  const filter = (payload: Amity.FollowersPayload | Amity.FollowStatusPayload) => {
     if (!client.cache) {
-      callback(payload);
+      callback(payload.follows[0]);
     } else {
-      ingestInCache({ follows: [payload] });
+      ingestInCache(payload);
 
       const queries = [
         ...(queryCache(['followers', 'query']) ?? []),
@@ -21,11 +21,14 @@ export const createFollowEventSubscriber = (
       ];
 
       queries
-        // @ts-ignore
-        .filter(({ key }) => key[2].userId === payload.from || key[2].userId === payload.to)
+        .filter(
+          ({ key }) =>
+            // @ts-ignore
+            key[2].userId === payload.follows[0].from || key[2].userId === payload.follows[0].to,
+        )
         .forEach(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
 
-      callback(payload);
+      callback(payload.follows[0]);
     }
   };
 

package/src/follow/observers/index.ts

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

package/src/follow/observers/liveFollowers.ts

@@ -0,0 +1,149 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions, filterByPropEquality } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+import { queryFollowers } from '../api';
+
+/**
+ * ```js
+ * import { liveFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = liveFollowers({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followers for a given userId
+ *
+ * @param userId the 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 Followers Live Collection
+ */
+export const liveFollowers = (
+  params: Amity.FollowerLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveFollowers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['follow', 'collection', { userId: params.userId, type: 'follower' }];
+
+  const responder = (data: Amity.FollowerLiveCollectionCache) => {
+    let followers: Amity.FollowStatus[] =
+      data.data
+        .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.status) {
+      followers = filterByPropEquality(followers, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.userId !== followStatus.to || !collection) return;
+
+    if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+    } else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+      collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
+
+    const followers = collection?.data ?? [];
+
+    if (followers.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryFollowers, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: followers,
+        };
+
+        if (result) {
+          data.data = [...new Set([...followers, ...result.map(getResolver('follow'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
+    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
+    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
+    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
+    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
+    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
+    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/liveFollowings.ts

@@ -0,0 +1,149 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions, filterByPropEquality } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+import { queryFollowings } from '../api';
+
+/**
+ * ```js
+ * import { liveFollowings } from '@amityco/ts-sdk'
+ *
+ * let followings = []
+ * const unsub = liveFollowings({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followings, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followings for a given userId
+ *
+ * @param userId the 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 Followings Live Collection
+ */
+export const liveFollowings = (
+  params: Amity.FollowingLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveFollowings(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['follow', 'collection', { userId: params.userId, type: 'following' }];
+
+  const responder = (data: Amity.FollowingLiveCollectionCache) => {
+    let followings: Amity.FollowStatus[] =
+      data.data
+        .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.status) {
+      followings = filterByPropEquality(followings, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followings,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.userId !== followStatus.from || !collection) return;
+
+    if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+    } else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+      collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
+
+    const followings = collection?.data ?? [];
+
+    if (followings.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryFollowings, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: followings,
+        };
+
+        if (result) {
+          data.data = [...new Set([...followings, ...result.map(getResolver('follow'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
+    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
+    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
+    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
+    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
+    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
+    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowings(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/index.ts

@@ -1,5 +1,5 @@
 // types
-import './@types';
+export * from './@types';
 
 export * from './version';
 
@@ -25,6 +25,7 @@ export * from './role/api';
 // // asc partials
 export * from './reaction/api';
 export * from './reaction/events';
+export * from './reaction/observers';
 
 export * from './report/api';
 

package/src/message/api/queryMessages.ts

@@ -19,16 +19,9 @@ import { getResolver } from '~/core/model';
  * @category Message API
  * @async
  */
-export const queryMessages = async (query: {
-  channelId: Amity.Channel['channelId'];
-  type?: Amity.MessageContentType;
-  parentId?: Amity.Message['parentId'];
-  filterByParentId?: boolean;
-  isDeleted?: boolean;
-  tags?: Amity.Taggable['tags'];
-  excludeTags?: Amity.Taggable['tags'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
+export const queryMessages = async (
+  query: Amity.QueryMessages,
+): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 

package/src/message/observers/index.ts

@@ -1,2 +1,3 @@
 export { observeMessage } from './observeMessage';
 export { observeMessages } from './observeMessages';
+export { liveMessages } from './liveMessages';