@amityco/ts-sdk 0.0.1-beta.36 → 0.0.1-beta.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.36",
+  "version": "0.0.1-beta.38",
   "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/errors.ts

@@ -31,6 +31,7 @@ declare global {
       QUERY_IN_PROGRESS = 800170,
       CONNECTION_ERROR = 800210,
       DISCONNECTED = 800211,
+      TOKEN_EXPIRED = 800403,
       DISALOOW_UNSYNCED_OBJECT = 800800,
     }
 

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

@@ -39,6 +39,7 @@ declare global {
       close: Error;
       end: undefined;
       reconnect: undefined;
+      'user.didGlobalBan': Amity.UserPayload;
     };
 
     type MqttChannelUserEvents = {
@@ -79,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;
     };
@@ -149,6 +151,11 @@ declare global {
       'local.message-feed.deleted': Amity.SubChannelPayload;
       'poll.updated': Amity.PollPayload;
       'poll.deleted': Amity.PollPayload;
+
+      sessionStateChange: Amity.SessionStates;
+      // used by accessTokenExpiryWatcher
+      tokenExpired: Amity.SessionStates.TOKEN_EXPIRED;
+      tokenTerminated: Amity.SessionStates.TERMINATED;
     };
 
     type Events = WsEvents & MqttEvents & MqttRTE & LocalEvents;

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/client.ts

@@ -5,6 +5,27 @@ declare global {
   namespace Amity {
     type Logger = (topic: string, ...args: any[]) => void;
 
+    const enum SessionStates {
+      NOT_LOGGED_IN = 'notLoggedIn',
+
+      ESTABLISHING = 'establishing',
+      ESTABLISHED = 'established',
+
+      TOKEN_EXPIRED = 'tokenExpired',
+
+      /*
+       * Terminated is slightly different from NOT_LOGGED_IN:
+       *
+       * After established, upon receiving the termination code, the SDK will move to terminated.
+       * Unlike tokenExpired that users can regain SDK usability by giving an auth token.
+       * This state represents unrecoverable failures. The app must manually re-login with a valid user.
+       *
+       * For more details, please check tech spec:
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#terminated
+       */
+      TERMINATED = 'terminated',
+    }
+
     type Client = {
       version: string;
 
@@ -14,14 +35,24 @@ declare global {
       ws: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
 
+      sessionState: Amity.SessionStates;
+      sessionHandler?: Amity.SessionHandler;
+
       cache?: Amity.Cache;
 
       apiKey?: string;
       userId?: string;
-      accessToken?: string;
+
+      token?: Omit<Amity.Tokens, 'refreshToken'>;
 
       use: () => void;
 
+      accessTokenExpiryWatcher: (
+        expiresAt: Amity.Tokens['expiresAt'],
+        issuedAt: Amity.Tokens['issuedAt'],
+        sessionHandler: Amity.SessionHandler,
+      ) => Amity.Unsubscriber;
+
       getFeedSettings: () => Promise<Amity.FeedSettings>;
     };
 
@@ -37,8 +68,21 @@ declare global {
     type Tokens = {
       accessToken: string;
       refreshToken: string;
+      // issuedAt, expiresAt is in iso Date format
+      issuedAt: string;
+      expiresAt: string;
     };
 
+    type AccessTokenRenewal = {
+      renew: () => void;
+      renewWithAuthToken: (authToken: string) => void;
+      unableToRetrieveAuthToken: () => void;
+    };
+
+    interface SessionHandler {
+      sessionWillRenewAccessToken(renewal: AccessTokenRenewal): void;
+    }
+
     type ChatSettings = {
       enabled: boolean;
       mention: {

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/global.ts

@@ -28,3 +28,22 @@ declare global {
 
   type ValueOf<T extends Record<any, any>> = T[keyof T];
 }
+
+/*
+ * Extented to pass token expiry into request config, for internal use only.
+ * Since it's in the request config, it does not get sent for the server, and
+ * allows us to intercept the tokenExpiry value to check if the token has not
+ * expired & cancel the request if yes.
+ *
+ */
+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/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),
+        }),
+      ),
+    );
+  });
+});

package/src/channel/api/tests/createChannel.test.ts

@@ -1,20 +1,44 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
-import { channelPayload, client } from '~/utils/tests';
+import {
+  channelPayload,
+  client,
+  conversationChannelPayload,
+  liveChannelPayload,
+} from '~/utils/tests';
 import { prepareChannelPayload } from '~/channel/utils';
 import { createChannel } from '../createChannel';
 
 const resPayload = { data: channelPayload };
 
 describe('createChannel', () => {
-  const channel = prepareChannelPayload(channelPayload).channels[0];
-
-  test('it should create a channel', async () => {
+  // integration_test_id: 9d80fd54-9e6d-454d-8344-6f9436b8e495
+  test('it should create a channel for community', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
 
     const res = await createChannel({ type: 'community' });
 
     expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(channel);
+    expect(res.data).toStrictEqual(prepareChannelPayload(channelPayload).channels[0]);
+  });
+
+  // integration_test_id: cef520ab-027d-4c5b-836c-a7f63ddc5146
+  test('it should create a channel for live', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: liveChannelPayload });
+
+    const res = await createChannel({ type: 'live' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(liveChannelPayload).channels[0]);
+  });
+
+  // integration_test_id: 11a43612-ff6f-4262-874c-4419d342cff1
+  test('it should create a channel for conversation', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: conversationChannelPayload });
+
+    const res = await createChannel({ type: 'conversation' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(conversationChannelPayload).channels[0]);
   });
 
   test('it should add channel to cache', async () => {
@@ -27,7 +51,7 @@ describe('createChannel', () => {
     const data = pullFromCache(['channel', 'get', channelId]);
 
     expect(data).toBeDefined();
-    expect(data?.data).toStrictEqual(channel);
+    expect(data?.data).toStrictEqual(prepareChannelPayload(channelPayload).channels[0]);
 
     disableCache();
   });

package/src/channel/api/tests/getChannel.test.ts

@@ -12,7 +12,8 @@ const { channelId } = channelQueryResponse.data.channels[0];
 const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
 
 describe('getChannel', () => {
-  test('it should return a channel', async () => {
+  // integration_test_id: b331e01c-20db-4f17-979b-b280d8818792
+  test('it should return a valid channel', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
 
     const expected = channel;
@@ -31,6 +32,7 @@ describe('getChannel', () => {
     disableCache();
   });
 
+  // integration_test_id: da9dc3e8-01fd-4e76-a26b-ac8333a69b23
   test('it should return an error', async () => {
     client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));