@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/client/api/markerSync.ts

@@ -0,0 +1,51 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { markerSync } from '@amityco/ts-sdk-react-native'
+ * const success = await markerSync()
+ * ```
+ *
+ * Make all markers synced
+ * * If response is empty means that the sync has ended.
+ * * If response is not empty, the sync has not ended. You must call markerSync
+ * again to continue syncing.
+ *
+ * @return {hasMore} A success boolean if the marker sync was ended.
+ *
+ * @category Marker API
+ * @async
+ * @private
+ */
+export const markerSync = async (
+  deviceLastSyncAt: string,
+): Promise<{
+  data: Amity.MarkerSyncPayload;
+  hasMore: boolean;
+}> => {
+  const client = getActiveClient();
+  client.log('channel/markerSync');
+
+  const { data: payload } = await client.http.post<Amity.MarkerSyncPayload>(
+    `/api/v1/markers/sync`,
+    { deviceLastSyncAt },
+  );
+
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.MarkerSyncPayload, { cachedAt });
+
+  fireEvent('local.feedMarker.fetched', { feedMarkers });
+  fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+  fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+  fireEvent('local.userMarker.fetched', { userMarkers });
+
+  return {
+    data: payload,
+    hasMore: payload.feedMarkers.length > 0,
+  };
+};

package/src/client/api/renewal.ts

@@ -0,0 +1,78 @@
+import { getDeviceId } from '~/core/device';
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { getActiveUser } from './activeUser';
+import { setClientToken as refreshToken } from '../utils/setClientToken';
+import { getActiveClient } from './activeClient';
+import { login } from './login';
+
+/* begin_public_function
+  id: client.renew_access_token
+*/
+/*
+ * Renewal defintion accepted by SessionHandler interface
+ *
+ * Tech Spec:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-Handler
+ *
+ * @category private
+ */
+export const renewal = (): Amity.AccessTokenRenewal => {
+  let tokenRenewed = false;
+  let renewTimeoutId: ReturnType<typeof setTimeout>;
+
+  const client = getActiveClient();
+
+  client.log('initiating access token renewal');
+  /*
+   * Renews a token if it is hasn't been renewed before. Also marks token as
+   * renewed once done
+   * Per instance of Renewal, only one renewal is allowed
+   */
+  const renewToken = async (authToken?: Amity.ConnectClientParams['authToken']): Promise<void> => {
+    const { userId, displayName } = getActiveUser();
+    const deviceId = getDeviceId();
+
+    const params = { userId, displayName, authToken, deviceId };
+
+    if (client.sessionState === Amity.SessionStates.TOKEN_EXPIRED) {
+      // sessionHandler will never be empty when renewal is instantiatied
+      await login(params, client.sessionHandler!);
+    } else {
+      // about to expire
+
+      // @ts-ignore: in that particular case, typing can be
+      // ignored since we enforce default values just before.
+      await refreshToken(params);
+    }
+
+    tokenRenewed = true;
+
+    if (renewTimeoutId) clearTimeout(renewTimeoutId);
+  };
+
+  return {
+    renew: () => {
+      if (tokenRenewed) {
+        console.log("'renew' method can be called only once per renewal instance");
+        return;
+      }
+      renewToken();
+    },
+
+    renewWithAuthToken: (authToken: string) => {
+      if (tokenRenewed) {
+        console.log("'renewWithAuthToken' method can be called only once per renewal instance");
+        return;
+      }
+      renewToken(authToken);
+    },
+
+    unableToRetrieveAuthToken: () => {
+      renewTimeoutId = setTimeout(() => {
+        client.sessionHandler?.sessionWillRenewAccessToken(renewal());
+      }, ACCESS_TOKEN_WATCHER_INTERVAL);
+    },
+  };
+};
+/* end_public_function */

package/src/client/api/setSessionState.ts

@@ -0,0 +1,80 @@
+import { ASCError } from '~/core/errors';
+
+import { getActiveClient } from './activeClient';
+
+/*
+ * Session States cannot be set arbitarily.
+ * These are the possible new states based on the current state
+ * Check tech spec for details:
+ * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Session-State
+ */
+const sessisonStateTransitions: Record<Amity.SessionStates, Amity.SessionStates[]> = {
+  // notLoggedIn -> establishing
+  [Amity.SessionStates.NOT_LOGGED_IN]: [Amity.SessionStates.ESTABLISHING],
+  // terminated -> establishing
+  [Amity.SessionStates.TERMINATED]: [Amity.SessionStates.ESTABLISHING],
+  // establishing -> notLoggedIn, established
+  [Amity.SessionStates.ESTABLISHING]: [
+    Amity.SessionStates.NOT_LOGGED_IN,
+    Amity.SessionStates.ESTABLISHED,
+  ],
+  /*
+   * established -> notLoggedIn, terminated, tokenExpired, establishing (for
+   * cases when logging in same user)
+   */
+  [Amity.SessionStates.ESTABLISHED]: [
+    Amity.SessionStates.NOT_LOGGED_IN,
+    Amity.SessionStates.TERMINATED,
+    Amity.SessionStates.TOKEN_EXPIRED,
+    Amity.SessionStates.ESTABLISHING,
+  ],
+  // tokenExpired -> establishing
+  [Amity.SessionStates.TOKEN_EXPIRED]: [Amity.SessionStates.ESTABLISHING],
+};
+
+export const isValidStateChange = (
+  prevState: Amity.SessionStates,
+  nextState: Amity.SessionStates,
+): boolean => {
+  return sessisonStateTransitions[prevState].includes(nextState);
+};
+
+/**
+ * Checks if a {@link Amity.Client} instance is connected to ASC servers
+ *
+ *
+ * @param state the new session state
+ * @returns a success boolean if connected
+ *
+ * @category private
+ */
+export const setSessionState = (state: Amity.SessionStates): boolean => {
+  const client = getActiveClient();
+
+  client.log('client/api/setSessionState', state);
+
+  const { sessionState: prevState } = client;
+
+  if (prevState === state) return false;
+
+  // check if transition is valid
+  if (!isValidStateChange(prevState, state)) {
+    throw new ASCError(
+      `Session state cannot change from ${prevState} to ${state}`,
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+  }
+
+  client.sessionState = state;
+
+  /*
+   * TODO: use a seperate emitter instance for session state changes
+   *
+   * This needs to be sync (check logout.ts for more info). Otherwise it will
+   * never be triggered as the all events are cleared on logout
+   */
+  client.emitter.emit('sessionStateChange', state);
+
+  return true;
+};

package/src/client/api/terminateClient.ts

@@ -0,0 +1,28 @@
+import { logout } from './logout';
+import { setSessionState } from './setSessionState';
+import { getActiveClient } from './activeClient';
+
+/**
+ * Terminates {@link Amity.Client} instance
+ *
+ *
+ *
+ * @category private
+ */
+export const terminateClient = (terminationReason?: Amity.TokenTerminationReason) => {
+  const client = getActiveClient();
+
+  setSessionState(Amity.SessionStates.TERMINATED);
+
+  if (client.http.defaults.metadata) {
+    if (terminationReason === Amity.TokenTerminationReason.GLOBAL_BAN)
+      client.http.defaults.metadata.isGlobalBanned = true;
+
+    if (terminationReason === Amity.TokenTerminationReason.USER_DELETED)
+      client.http.defaults.metadata.isUserDeleted = true;
+  }
+
+  client.sessionHandler = undefined;
+
+  logout();
+};

package/src/client/api/tests/accessTokenExpiryWatcher.test.ts

@@ -0,0 +1,132 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { accessTokenExpiryWatcher, isAboutToExpire, isExpired } from '../accessTokenExpiryWatcher';
+
+import { onTokenExpired } from '~/client/events/onTokenExpired';
+
+describe('accessTokenExpiryWatcher', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  const expiresAt = new Date().toISOString();
+  const issuedAt = new Date().toISOString();
+
+  test('it should fire event when session expires', async () => {
+    const sessionHandler: Amity.SessionHandler = {
+      sessionWillRenewAccessToken(_) {
+        // do nothing
+      },
+    };
+
+    jest.useFakeTimers();
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.TOKEN_EXPIRED;
+
+    const unsub = onTokenExpired(callback);
+    const stopWatcher = accessTokenExpiryWatcher(expiresAt, issuedAt, sessionHandler!);
+
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL + 1);
+
+    expect(callback).toBeCalledWith(expected);
+
+    unsub();
+    stopWatcher();
+  });
+
+  test('it should renew token if session is about to expire', async () => {
+    jest.useFakeTimers();
+    const callback = jest.fn();
+
+    const sessionHandler = { sessionWillRenewAccessToken: callback };
+    client.sessionHandler = sessionHandler;
+
+    const stopWatcher = accessTokenExpiryWatcher(expiresAt, issuedAt, sessionHandler);
+
+    const oldIssuedAtTime = new Date();
+    const aboutToExpireTime = new Date();
+
+    aboutToExpireTime.setMinutes(aboutToExpireTime.getMinutes() + 30);
+    oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 1);
+
+    aboutToExpireTime.setHours(aboutToExpireTime.getHours() + 1);
+
+    if (client.token) {
+      client.token.expiresAt = aboutToExpireTime.toISOString();
+      client.token.issuedAt = oldIssuedAtTime.toISOString();
+    }
+
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL + 1);
+    stopWatcher();
+
+    expect(callback).toHaveBeenCalled();
+  });
+
+  test('it should renew token if session has expired', async () => {
+    jest.useFakeTimers();
+    const callback = jest.fn();
+
+    const sessionHandler = { sessionWillRenewAccessToken: callback };
+    client.sessionHandler = sessionHandler;
+
+    const stopWatcher = accessTokenExpiryWatcher(expiresAt, issuedAt, sessionHandler);
+    if (client.token) client.token.expiresAt = new Date().toISOString();
+
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL + 1);
+
+    expect(callback).toHaveBeenCalled();
+
+    stopWatcher();
+  });
+});
+
+describe('accessTokenExpiryWatcher > aboutToExpire', () => {
+  const expiresAt = new Date().toISOString();
+  const issuedAt = new Date().toISOString();
+  const oldIssuedAtTime = new Date();
+  const aboutToExpireTime = new Date();
+
+  test('it should return true if about to expire', () => {
+    oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 1);
+
+    aboutToExpireTime.setHours(aboutToExpireTime.getHours() + 1);
+
+    expect(
+      isAboutToExpire({
+        expiresAt: aboutToExpireTime.toISOString(),
+        issuedAt: oldIssuedAtTime.toISOString(),
+      }),
+    ).toBe(true);
+  });
+
+  test('it should return false if token expired', () => {
+    expect(isAboutToExpire({ expiresAt, issuedAt })).toBe(false);
+  });
+
+  test('it should return false if not about to expire', () => {
+    oldIssuedAtTime.setDate(oldIssuedAtTime.getDate() - 10);
+
+    expect(isAboutToExpire({ expiresAt, issuedAt })).toBe(false);
+  });
+});
+
+describe('accessTokenExpiryWatcher > isExpired', () => {
+  let expiresAt = new Date().toISOString();
+
+  test('it should return true if token expired', () => {
+    expect(isExpired(expiresAt)).toBe(true);
+  });
+
+  test('it should return false if token not about expired', () => {
+    const laterDate = new Date();
+    laterDate.setMonth(laterDate.getMonth() + 1);
+    expiresAt = laterDate.toISOString();
+
+    expect(isExpired(expiresAt)).toBe(false);
+  });
+});

package/src/client/api/tests/activeClient.test.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '../activeClient';
+import { connectClient, disconnectClient } from '~/utils/tests';
+
+describe('API: Active Client', () => {
+  afterAll(disconnectClient);
+
+  test('should got error message when activeClient is offline', () => {
+    try {
+      getActiveClient();
+    } catch (error) {
+      expect(String(error)).toContain('Error: Amity SDK (800000): There is no active client');
+    }
+  });
+
+  test('should get client when activeClient is online', async () => {
+    await connectClient();
+    const data = getActiveClient();
+    expect(data.userId).toBe('test');
+  });
+});

package/src/client/api/tests/activeUser.test.ts

@@ -0,0 +1,20 @@
+import { getActiveUser } from '../activeUser';
+import { connectClient, disconnectClient } from '~/utils/tests';
+
+describe('API: Active User', () => {
+  afterAll(disconnectClient);
+
+  test('should got error message when client is offline', () => {
+    try {
+      getActiveUser();
+    } catch (error) {
+      expect(String(error)).toContain('Error: Amity SDK (800000): Connect client first');
+    }
+  });
+
+  test('should get active user when client is online', async () => {
+    await connectClient();
+    const data = getActiveUser();
+    expect(data.userId).toBe('test');
+  });
+});

package/src/client/api/tests/createClient.test.ts

@@ -0,0 +1,48 @@
+import { createClient } from '../createClient';
+
+describe('createClient', () => {
+  test('it should create client', () => {
+    const client = createClient('test-api-key');
+
+    expect(client).toBeDefined();
+  });
+
+  test('it should define http transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.http).toBeDefined();
+  });
+
+  test('it should define ws transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.ws).toBeDefined();
+  });
+
+  test('it should define mqtt transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.mqtt).toBeDefined();
+  });
+
+  test('it should define event emitter', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.emitter).toBeDefined();
+  });
+
+  test('it should return existing client if there is one', () => {
+    const expected = createClient('test-api-key');
+    const recieved = createClient('test-api-key');
+
+    expect(recieved).toStrictEqual(expected);
+  });
+
+  test('it should set not logged in as the start up session state', () => {
+    const got = createClient('key', 'sg');
+    const { sessionState } = got;
+
+    expect(got).toBeDefined();
+    expect(sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
+});

package/src/client/api/tests/getToken.test.ts

@@ -0,0 +1,36 @@
+import { client, user11, sessionResponse } from '~/utils/tests';
+
+import { getToken } from '../getToken';
+
+describe('getToken', () => {
+  const { userId } = user11;
+  const displayName = 'test-displayName';
+  const deviceId = 'test-deviceId';
+  const params = { userId, displayName, deviceId };
+
+  test('it should call v4/sessions api', async () => {
+    const expected = '/api/v4/sessions';
+    const mockApi = jest.fn().mockResolvedValue(sessionResponse);
+    client.http.post = mockApi;
+
+    await getToken(params);
+    const [recieved] = mockApi.mock.lastCall;
+
+    expect(recieved).toBe(expected);
+  });
+
+  test('it should return token', async () => {
+    const expected = sessionResponse.data;
+    client.http.post = jest.fn().mockResolvedValue(sessionResponse);
+
+    const recieved = await getToken(params);
+
+    expect(recieved).toStrictEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.post = jest.fn().mockRejectedValue(new Error('error'));
+
+    await expect(getToken(params)).rejects.toThrow();
+  });
+});

package/src/client/api/tests/login.test.ts

@@ -0,0 +1,82 @@
+import { ASCApiError } from '~/core/errors';
+import { sessionResponse, user11, disconnectClient } from '~/utils/tests';
+import { login, createClient } from '..';
+import { setActiveClient } from '../activeClient';
+
+let client: Amity.Client;
+
+const sessionHandler: Amity.SessionHandler = {
+  sessionWillRenewAccessToken(_) {
+    // do nothing
+  },
+};
+
+const onConnect = () =>
+  setTimeout(() => {
+    const CONNECT_PACKET = { type: 0, nsp: client.ws.nsp };
+
+    client.ws.emit('connect');
+
+    // simulate a connection ack packet from server
+    client.ws.io.emit('packet', CONNECT_PACKET);
+  }, 50);
+
+describe('login', () => {
+  beforeEach(() => {
+    client = createClient('key', 'sg');
+    client.mqtt.connect = jest.fn();
+    client.mqtt.subscribe = jest.fn();
+    client.http.post = jest.fn().mockResolvedValueOnce(sessionResponse);
+
+    setActiveClient(client);
+  });
+
+  afterEach(async () => {
+    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+  });
+
+  test('it should connect client', async () => {
+    onConnect().unref();
+
+    const recieved = await login({ userId: user11.userId }, sessionHandler);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should establish connection', async () => {
+    onConnect().unref();
+
+    await login({ userId: user11.userId }, sessionHandler);
+    const { sessionState } = client;
+
+    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+  });
+
+  test('it should have session state establishing while connecting client', () => {
+    login({ userId: user11.userId }, sessionHandler);
+
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+  });
+
+  test('it should have session state notLoggedIn on failure', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValue(
+        new ASCApiError('unauthorzed', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(login({ userId: user11.userId }, sessionHandler)).rejects.toThrow('unauthorzed');
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
+
+  test('it should terminate session on ban', async () => {
+    onConnect().unref();
+
+    await login({ userId: user11.userId }, sessionHandler);
+
+    // ban user
+    client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
+
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+  });
+});

package/src/client/api/tests/logout.test.ts

@@ -0,0 +1,78 @@
+import { pushToCache, pullFromCache, enableCache } from '~/cache/api';
+import { client, connectClient, message11 as message } from '~/utils/tests';
+
+import { logout } from '..';
+
+const disconnect = () => setTimeout(() => client.ws.emit('disconnect'), 500);
+
+describe('logout', () => {
+  beforeEach(async () => {
+    await connectClient();
+  });
+
+  test('it should disconnect client', async () => {
+    disconnect().unref();
+
+    const recieved = await logout();
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should set sesion state to notLoggedIn after disconnect', async () => {
+    disconnect().unref();
+    await logout();
+
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
+
+  test('it should not update sesion state if session state terminated', async () => {
+    client.sessionState = Amity.SessionStates.TERMINATED;
+    disconnect().unref();
+
+    await logout();
+
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+  });
+
+  test('it should clear userId and accessToken on disconnect', async () => {
+    disconnect().unref();
+
+    await logout();
+
+    expect(client.userId).toBeUndefined();
+    expect(client.token).toBeUndefined();
+  });
+
+  test('it should clear auth header on disconnect', async () => {
+    disconnect().unref();
+
+    await logout();
+
+    expect(client.http.defaults.headers.common.Authorization).toBeFalsy();
+  });
+
+  test('it should clear cache on disconnect', async () => {
+    disconnect().unref();
+    enableCache();
+
+    const cacheKey = ['message', 'get', message.messageId];
+    pushToCache(cacheKey, message);
+
+    await logout();
+
+    expect(pullFromCache(cacheKey)).toBeUndefined();
+  });
+
+  test('it should not clear cache if tokenExpired', async () => {
+    client.sessionState = Amity.SessionStates.TOKEN_EXPIRED;
+    disconnect().unref();
+    enableCache();
+
+    const cacheKey = ['message', 'get', message.messageId];
+    pushToCache(cacheKey, message);
+
+    await logout();
+
+    expect(pullFromCache(cacheKey)?.data).toStrictEqual(message);
+  });
+});