@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

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

@@ -4,16 +4,16 @@ import { createEventSubscriber } from '~/core/events';
 import { queryCache, upsertInCache } from '~/cache/api';
 
 export const createFollowEventSubscriber = (
-  event: keyof Amity.MqttFollowMessageEvents,
+  event: keyof Amity.MqttFollowEvents,
   callback: Amity.Listener<Amity.FollowStatus>,
 ) => {
   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,7 @@
 export * from './observeFollowInfo';
 export * from './observeFollowers';
 export * from './observeFollowings';
+
+export * from './liveFollowers';
+export * from './liveFollowings';
+export * from './liveFollowInfo';

package/src/follow/observers/liveFollowInfo.ts

@@ -0,0 +1,29 @@
+import { liveObject } from '~/utils/liveObject';
+import { getFollowInfo } from '../api';
+import { onFollowInfoUpdated } from '../events';
+
+/**
+ * ```js
+ * import { liveFollowInfo } from '@amityco/ts-sdk';
+ *
+ * let followInfo;
+ *
+ * const unsubscribe = liveFollowInfo(userId, response => {
+ *   followInfo = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.FollowCount} object
+ *
+ * @param userId the ID of the current 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
+ *
+ * @category FollowInfo Live Object
+ */
+export const liveFollowInfo = (
+  userId: Amity.FollowInfo['userId'],
+  callback: Amity.LiveObjectCallback<Amity.FollowInfo>,
+): Amity.Unsubscriber => {
+  return liveObject(userId, callback, 'userId', getFollowInfo, [onFollowInfoUpdated]);
+};

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 && params.status !== 'all') {
+      followers = filterByPropEquality(followers, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.FollowActionType) => (followStatus: Amity.FollowStatus) => {
+    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(realtimeRouter('onRequested')),
+    onFollowRequestAccepted(realtimeRouter('onAccepted')),
+    onFollowRequestDeclined(realtimeRouter('onDeclined')),
+    onFollowRequestCanceled(realtimeRouter('onCanceled')),
+    onUserFollowed(realtimeRouter('onFollowed')),
+    onUserUnfollowed(realtimeRouter('onUnfollowed')),
+    onFollowerDeleted(realtimeRouter('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 && params.status !== 'all') {
+      followings = filterByPropEquality(followings, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followings,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.FollowActionType) => (followStatus: Amity.FollowStatus) => {
+    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(realtimeRouter('onRequested')),
+    onFollowRequestAccepted(realtimeRouter('onAccepted')),
+    onFollowRequestDeclined(realtimeRouter('onDeclined')),
+    onFollowRequestCanceled(realtimeRouter('onCanceled')),
+    onUserFollowed(realtimeRouter('onFollowed')),
+    onUserUnfollowed(realtimeRouter('onUnfollowed')),
+    onFollowerDeleted(realtimeRouter('onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowings(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/tests/liveFollowInfo.test.ts

@@ -0,0 +1,198 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follow21,
+  follow11,
+  user11,
+  pause,
+  date,
+} from '~/utils/tests';
+
+import { liveFollowInfo } from '../liveFollowInfo';
+
+const FOLLOWING_COUNT = 2;
+const getFollowInfoMePayload = ({
+  userId = user11.userId,
+  followerCount = 0,
+  pendingCount = 0,
+  followingCount = FOLLOWING_COUNT,
+} = {}): Amity.FollowInfoMePayload => {
+  return {
+    followCounts: [
+      {
+        userId,
+        followerCount,
+        pendingCount,
+        followingCount,
+      },
+    ],
+  };
+};
+
+const getFollowMeStatusPayload = (
+  status: Amity.FollowStatus['status'] = follow11.status,
+): Amity.FollowStatusPayload => {
+  return {
+    follows: [
+      {
+        from: follow11.from,
+        to: follow11.to,
+        status,
+        createdAt: date,
+        updatedAt: date,
+      },
+    ],
+  };
+};
+
+const getFollowStatusPayload = (
+  status: Amity.FollowStatus['status'] = follow21.status,
+): Amity.FollowStatusPayload => {
+  return {
+    follows: [
+      {
+        from: follow21.from,
+        to: follow21.to,
+        status,
+        createdAt: date,
+        updatedAt: date,
+      },
+    ],
+  };
+};
+
+describe('liveFollowInfo > me', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const tests: [
+    string,
+    keyof Amity.MqttFollowEvents,
+    Amity.FollowStatusPayload,
+    Amity.FollowInfoMePayload,
+  ][] = [
+    [
+      'it should update follow info collection on accepted',
+      'follow.accepted',
+      getFollowMeStatusPayload('accepted'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({ data: getFollowInfoMePayload() })
+      .mockResolvedValueOnce({ data: payloadFrom })
+      .mockResolvedValueOnce({ data: payloadFrom });
+
+    const unsub = liveFollowInfo(user11.userId, callback);
+    await pause();
+
+    client.emitter.emit(event, payload);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: payloadFrom.followCounts[0],
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+});
+
+describe('liveFollowInfo > other', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const tests: [
+    string,
+    keyof Amity.MqttFollowEvents,
+    Amity.FollowStatusPayload,
+    Amity.FollowInfoMePayload,
+  ][] = [
+    [
+      'it should update follow info collection on accepted',
+      'follow.accepted',
+      getFollowStatusPayload('accepted'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({ data: getFollowInfoMePayload({ userId: follow21.from }) })
+      .mockResolvedValueOnce({ data: payloadFrom })
+      .mockResolvedValueOnce({ data: payloadFrom });
+
+    const unsub = liveFollowInfo(follow21.from, callback);
+    await pause();
+
+    client.emitter.emit(event, payload);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: payloadFrom.followCounts[0],
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+});