@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.39

package/dist/utils/tests/dummy/subChannel.d.ts

@@ -1,23 +1,3 @@
 export declare function generateRawSubChannel(params?: Partial<Amity.RawSubChannel>): Amity.RawSubChannel;
 export declare function generateSubChannel(params?: Record<string, any>): Amity.SubChannel;
-export declare const createSubChannelError400400: {
-    status: string;
-    message: string;
-    code: number;
-    data: {
-        detail: {
-            channelId: string;
-        };
-    };
-};
-export declare const createSubChannelError400301: {
-    status: string;
-    message: string;
-    code: number;
-    data: {
-        detail: {
-            channelId: string;
-        };
-    };
-};
 //# sourceMappingURL=subChannel.d.ts.map

package/dist/utils/tests/dummy/subChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subChannel.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/subChannel.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,aAAa,CAkBhG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,UAAU,CAKjF;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;CASvC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;CASvC,CAAC"}
+{"version":3,"file":"subChannel.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/subChannel.ts"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC,aAAa,CAkBhG;AAED,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,UAAU,CAKjF"}

package/dist/utils/tests/dummy/user.d.ts

@@ -2,6 +2,8 @@ export declare const user11: Amity.User;
 export declare const user12: Amity.User;
 export declare const user13: Amity.User;
 export declare const user14: Amity.User;
+export declare const user21: Amity.User;
+export declare const user22: Amity.User;
 export declare const userQueryResponse: {
     data: {
         users: Amity.User[];
@@ -12,6 +14,85 @@ export declare const userQueryResponse: {
         };
     };
 };
+export declare const userQueryResponsePage2: {
+    data: {
+        users: Amity.User[];
+        files: never[];
+        paging: {
+            previous: string;
+            next: string;
+        };
+    };
+};
+export declare const flaggedUser: {
+    userId: string;
+    flagCount: number;
+    _id: string;
+    displayName?: string | undefined;
+    avatarFileId?: string | undefined;
+    avatarCustomUrl?: string | undefined;
+    description?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    hashFlag: {
+        bits: number;
+        hashes: number;
+        hash: string;
+    } | null;
+    roles: string[];
+    permissions: Amity.Permission[];
+    createdAt: string;
+    updatedAt?: string | undefined;
+    deletedAt?: string | undefined;
+    isDeleted?: boolean | undefined;
+    path: string;
+};
+export declare const flaggedUserQueryResponse: {
+    data: {
+        users: {
+            userId: string;
+            flagCount: number;
+            _id: string;
+            displayName?: string | undefined;
+            avatarFileId?: string | undefined;
+            avatarCustomUrl?: string | undefined;
+            description?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            tags?: string[] | undefined;
+            hashFlag: {
+                bits: number;
+                hashes: number;
+                hash: string;
+            } | null;
+            roles: string[];
+            permissions: Amity.Permission[];
+            createdAt: string;
+            updatedAt?: string | undefined;
+            deletedAt?: string | undefined;
+            isDeleted?: boolean | undefined;
+            path: string;
+        }[];
+        files: never[];
+    };
+};
+export declare const userUpdateResponse: {
+    data: {
+        users: {
+            isDeleted: boolean;
+            displayName: string;
+            userId: string;
+            metadata: {};
+            roles: never[];
+            permissions: never[];
+            flagCount: number;
+            hashFlag: null;
+            avatarCustomUrl: string;
+            avatarFileId: null;
+            isGlobalBan: boolean;
+        }[];
+        files: never[];
+    };
+};
 export declare const users: Amity.User[];
 export declare const userPayload: Amity.UserPayload;
 //# sourceMappingURL=user.d.ts.map

package/dist/utils/tests/dummy/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/user.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAS1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;CAS7B,CAAC;AACF,eAAO,MAAM,KAAK,cAAmC,CAAC;AAGtD,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,WAG/B,CAAC"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/user.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAS1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAI1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;CAS7B,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;CASlC,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;CAIvB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKpC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;CAmB9B,CAAC;AAEF,eAAO,MAAM,KAAK,cAAmC,CAAC;AAGtD,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,WAG/B,CAAC"}

package/dist/utils/tests/liveObject.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=liveObject.test.d.ts.map

package/dist/utils/tests/liveObject.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveObject.test.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/liveObject.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.37",
+  "version": "0.0.1-beta.39",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",
@@ -36,14 +36,15 @@
     "@rollup/plugin-commonjs": "^22.0.2",
     "@rollup/plugin-node-resolve": "^13.3.0",
     "@rollup/plugin-replace": "^4.0.0",
-    "@types/axios": "^0.14.0",
     "@types/debug": "^4.1.7",
     "@types/jest": "^27.5.1",
     "@types/node": "^18.6.4",
     "@types/socket.io-client": "^1.4.34",
     "chalk": "^4.1.2",
     "concurrently": "^6.1.0",
+    "form-data": "^4.0.0",
     "jest": "^28.1.0",
+    "nock": "^13.3.0",
     "rimraf": "^3.0.2",
     "rollup": "^2.77.2",
     "rollup-plugin-terser": "^7.0.2",
@@ -54,12 +55,11 @@
   "dependencies": {
     "@react-native-async-storage/async-storage": "^1.17.7",
     "agentkeepalive": "^4.2.1",
-    "axios": "^0.27.2",
+    "axios": "^1.2.3",
     "debug": "^4.3.4",
     "js-base64": "^3.7.2",
     "mitt": "^3.0.0",
     "mqtt": "^4.3.7",
-    "qs": "^6.11.0",
     "react-native-uuid": "^2.0.1",
     "socket.io-client": "2.2.0",
     "ts-jest": "^28.0.3"

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

@@ -80,6 +80,7 @@ declare global {
       'community.left': Amity.CommunityMembershipPayload;
       'community.userAdded': Amity.CommunityMembershipPayload;
       'community.userRemoved': Amity.CommunityMembershipPayload;
+      'community.userChanged': Amity.CommunityMembershipPayload;
       'community.userBanned': Amity.CommunityMembershipPayload;
       'community.userUnbanned': Amity.CommunityMembershipPayload;
     };

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

@@ -28,6 +28,8 @@ declare global {
 
       follow: Amity.FollowStatus;
       followCount: Amity.FollowCount;
+
+      feed: Amity.Feed;
     };
 
     type Domain = keyof Model;
@@ -59,6 +61,8 @@ declare global {
 
       follow: Pick<Amity.FollowStatus, 'from' | 'to'>;
       followCount: Pick<Amity.FollowCount, 'userId'>;
+
+      feed: Pick<Amity.Feed, 'targetId' | 'feedId'>;
     };
   }
 }

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

@@ -9,5 +9,18 @@ declare global {
     } & Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete;
+
+    type QueryCategories = {
+      isDeleted?: Amity.Category['isDeleted'];
+      sortBy?: 'name' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type CategoryLiveCollection = Amity.LiveCollectionParams<Omit<QueryCategories, 'page'>>;
+
+    type CategoryLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Category['categoryId'],
+      Pick<QueryCategories, 'page'>
+    >;
   }
 }

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

@@ -48,7 +48,7 @@ declare global {
       messageCount: number; // TODO remove from public interface
       moderatorMemberCount?: number;
 
-      lastActivity?: Amity.timestamp;
+      lastActivity: Amity.timestamp;
 
       defaultSubChannelUnreadCount: number;
       defaultSubChannelHasUnreadMention: boolean;
@@ -74,7 +74,7 @@ declare global {
     type QueryChannels = {
       displayName?: string;
       membership?: 'all' | 'member' | 'notMember';
-      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated' | 'lastActivity';
       types?: Amity.ChannelType[];
       isDeleted?: Amity.Channel['isDeleted'];
       tags?: Amity.Taggable['tags'];

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

@@ -23,6 +23,14 @@ export const DefaultCommunityPostSetting = 'ONLY_ADMIN_CAN_POST';
 
 declare global {
   namespace Amity {
+    type CommunityActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onJoin'
+      | 'onLeft'
+      | 'onMemberCountChanged';
+
     type RawCommunity = {
       communityId: string;
 
@@ -55,5 +63,22 @@ declare global {
     type Community = Omit<Amity.RawCommunity, 'onlyAdminCanPost' | 'needApprovalOnPostCreation'> & {
       postSetting?: ValueOf<typeof CommunityPostSettings>;
     };
+
+    type QueryCommunities = {
+      displayName?: string;
+      membership?: 'all' | 'member' | 'notMember';
+      categoryId?: Amity.Category['categoryId'];
+      isDeleted?: Amity.Community['isDeleted'];
+      tags?: Amity.Taggable['tags'];
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
+
+    type CommunityLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Community['communityId'],
+      Pick<QueryCommunities, 'page'>
+    >;
   }
 }

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

@@ -2,12 +2,10 @@ export {};
 
 declare global {
   namespace Amity {
-    type FeedType = 'community' | 'user';
-
     type Feed = {
       feedId: string;
       feedType: 'reviewing' | 'published';
-      targetType: FeedType;
+      targetType: Extract<Amity.Domain, 'community' | 'user'>;
       targetId: string;
       postCount: number;
     } & Amity.Timestamps;

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

@@ -76,7 +76,10 @@ declare global {
       excludeTags?: Amity.Taggable['tags'];
       hasFlags?: boolean;
       isDeleted?: boolean;
-      page?: Amity.Page;
+      /*
+       * For messages the after and before values are messageId
+       */
+      page?: Amity.Page<string>;
       parentId?: Amity.Message['parentId'];
       sortBy?: 'segmentAsc' | 'segmentDesc';
       tags?: Amity.Taggable['tags'];

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

@@ -10,7 +10,7 @@ export const PostContentType = Object.freeze({
 declare global {
   namespace Amity {
     // bad hack until we get proper feed objects in backend
-    type PostTargetType = Amity.FeedType | 'content';
+    type PostTargetType = Amity.Feed['targetType'] | 'content';
 
     type PostContentType = ValueOf<typeof PostContentType>;
 

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

@@ -24,5 +24,19 @@ declare global {
       Amity.Timestamps &
       Amity.SoftDelete &
       Amity.Subscribable;
+
+    type QueryUsers = {
+      displayName?: Amity.User['displayName'];
+      filter?: 'all' | 'flagged';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;
+
+    type UserLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.User['userId'],
+      Pick<QueryUsers, 'page'>
+    >;
   }
 }

package/src/@types/global.ts

@@ -37,6 +37,11 @@ declare global {
  *
  */
 declare module 'axios' {
+  export interface AxiosDefaults {
+    // expires at iso string for access token
+    metadata?: { tokenExpiry: string };
+  }
+
   export interface AxiosRequestConfig {
     // expires at iso string for access token
     metadata?: { tokenExpiry: string };

package/src/cache/api/tests/ingestInCache.test.ts

@@ -11,6 +11,7 @@ import {
   pollPayload,
   reactionPayload,
   followPayload,
+  feedPayload,
   user11,
 } from '~/utils/tests';
 
@@ -32,6 +33,7 @@ describe('ingestInCache', () => {
     ['poll', pollPayload],
     ['reaction', reactionPayload],
     ['follow', followPayload],
+    ['feed', feedPayload],
   ];
 
   test.each(payloads)('it should add %s payload to cache', (model, payload) => {

package/src/category/api/queryCategories.ts

@@ -20,11 +20,9 @@ import { getResolver } from '~/core/model';
  * @category Category API
  * @async
  * */
-export const queryCategories = async (query?: {
-  sortBy?: 'lastCreated' | 'firstCreated' | 'name';
-  isDeleted?: Amity.Category['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
+export const queryCategories = async (
+  query?: Amity.QueryCategories,
+): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
   const client = getActiveClient();
   client.log('category/queryCategories', query);
 

package/src/category/observers/index.ts

@@ -0,0 +1 @@
+export * from './liveCategories';

package/src/category/observers/liveCategories.ts

@@ -0,0 +1,141 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastCreated,
+  sortByName,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { queryCategories } from '../api';
+
+/**
+ * ```js
+ * import { liveCategories } from '@amityco/ts-sdk'
+ *
+ * let categories = []
+ * const unsub = liveCategories({}, response => merge(categories, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Category}s
+ *
+ * @param params for querying categories
+ * @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 categories
+ *
+ * @category Category Live Collection
+ */
+export const liveCategories = (
+  params: Amity.CategoryLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Category>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveCategories(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 = ['category', 'collection', {}];
+
+  const responder = (data: Amity.CategoryLiveCollectionCache) => {
+    let categories: Amity.Category[] =
+      data.data
+        .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    categories = filterByPropEquality(categories, 'isDeleted', params.isDeleted);
+
+    switch (params.sortBy) {
+      case 'firstCreated':
+        categories = categories.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        categories = categories.sort(sortByLastCreated);
+        break;
+
+      default:
+        categories = categories.sort(sortByName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: categories,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  /*
+   * const realtimeRouter = () => {
+   * @TODO: At the time of creating this method category does not have any
+   * observers
+   *};
+   */
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CategoryLiveCollectionCache>(cacheKey)?.data;
+
+    const categories = collection?.data ?? [];
+
+    if (categories.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCategories, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: categories,
+        };
+
+        if (result) {
+          data.data = [...new Set([...categories, ...result.map(getResolver('category'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(() => {
+    // @TODO -> update once observers added
+  });
+
+  onFetch();
+
+  return () => {
+    log(`liveCategories(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/category/observers/tests/liveCategories.test.ts

@@ -0,0 +1,147 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  categoryQueryResponse,
+  categoryQueryResponsePage2,
+  category11,
+  category12,
+  category13,
+} from '~/utils/tests';
+import { sortByName } from '~/core/query';
+
+import { liveCategories } from '../liveCategories';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Category[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('live Caategories', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const payload = categoryQueryResponse.data;
+  const payloadPage2 = categoryQueryResponsePage2.data;
+
+  test('it should return category collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories({}, () => undefined);
+    await pause();
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CategoryLiveCollection, Amity.Category[]][] = [
+    ['deleted', { isDeleted: true }, [category13]],
+    ['not deleted', { isDeleted: false }, [category11, category12]],
+  ];
+
+  test.each(filters)('it should filter by %s categories', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: expected,
+        }),
+      ),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(categoryQueryResponse)
+      .mockResolvedValueOnce(categoryQueryResponsePage2);
+
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    // 4 -> because 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: [...payloadPage2.categories, ...payload.categories].sort(sortByName),
+        }),
+      ),
+    );
+  });
+});