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

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

@@ -0,0 +1,67 @@
+import { ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+import { client, connectClient, disconnectClient, user11, pause } from '~/utils/tests';
+
+import { renewal } from '../renewal';
+
+const accessToken = 'renewed-access-token';
+const sessionResponse = {
+  data: {
+    accessToken,
+    refreshToken: 'test-refresh-token',
+    issuedAt: new Date(),
+    expiresAt: new Date(),
+    users: [user11],
+    files: [],
+  },
+};
+
+describe('renewal', () => {
+  beforeAll(connectClient);
+
+  afterAll(disconnectClient);
+
+  test('it should renew access token', async () => {
+    const mock = jest.fn();
+    client.http.post = mock.mockResolvedValue(sessionResponse);
+
+    renewal().renew();
+    await pause();
+
+    expect(client.token?.accessToken).toBe(accessToken);
+  });
+
+  test('it should show warning message if renewal already called', async () => {
+    client.http.post = jest.fn().mockResolvedValue(sessionResponse);
+    jest.spyOn(global.console, 'log');
+
+    const expected = "'renew' method can be called only once per renewal instance";
+    const renewalInstance = renewal();
+
+    renewalInstance.renew();
+    await pause();
+
+    renewalInstance.renew();
+    await pause();
+
+    expect(console.log).toBeCalledWith(expected);
+  });
+
+  test('it should call renewal later if unable to renew', async () => {
+    jest.useFakeTimers();
+    const sessionHandler: Amity.SessionHandler = {
+      sessionWillRenewAccessToken(renewal) {
+        renewal.renew();
+      },
+    };
+
+    client.sessionHandler = sessionHandler;
+
+    const mock = jest.fn();
+    client.http.post = mock.mockResolvedValue(sessionResponse);
+
+    renewal().unableToRetrieveAuthToken();
+    jest.advanceTimersByTime(ACCESS_TOKEN_WATCHER_INTERVAL);
+
+    expect(mock).toBeCalled();
+  });
+});

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

@@ -0,0 +1,62 @@
+import { ASCError } from '~/core/errors';
+import { getActiveClient } from '../activeClient';
+
+import { connectClient, disconnectClient, pause } from '~/utils/tests';
+
+import { setSessionState } from '../setSessionState';
+import { onSessionStateChange } from '../../events';
+
+describe('setSessionState', () => {
+  beforeEach(async () => {
+    await connectClient();
+  });
+
+  afterEach(async () => {
+    await disconnectClient();
+  });
+
+  test('it should set new session state', () => {
+    const client = getActiveClient();
+    const expected = Amity.SessionStates.NOT_LOGGED_IN;
+
+    setSessionState(expected);
+
+    expect(client.sessionState).toBe(expected);
+  });
+
+  test('it should return true if state changed successully', () => {
+    const expected = true;
+
+    const recieved = setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+    expect(recieved).toBe(expected);
+  });
+
+  test('it should fire event on state change', async () => {
+    const callback = jest.fn();
+
+    const expected = Amity.SessionStates.NOT_LOGGED_IN;
+    const unsub = onSessionStateChange(callback);
+
+    const recieved = setSessionState(expected);
+
+    // wait for event handler
+    await pause();
+
+    expect(recieved).toBe(true);
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not allow invalid state change', async () => {
+    /*
+     * as state changes from established -> established are not possible, even
+     * for cases when logging in with already logged in user it should go to
+     * establishing first
+     */
+    const nextState = Amity.SessionStates.ESTABLISHED;
+
+    expect(setSessionState(nextState)).toBe(false);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { client, connectClient } from '~/utils/tests';
+
+import { terminateClient } from '../terminateClient';
+
+const disconnect = () => setTimeout(() => client.ws.emit('disconnect'), 500);
+
+describe('terminateClient', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  test('it should terminate client session', async () => {
+    disconnect().unref();
+
+    const expected = Amity.SessionStates.TERMINATED;
+
+    terminateClient();
+
+    expect(client.sessionState).toBe(expected);
+  });
+
+  test('it should clear sessionHandler', async () => {
+    disconnect().unref();
+
+    terminateClient();
+
+    expect(client.sessionHandler).toBeUndefined();
+  });
+});

package/src/client/events/index.ts

@@ -0,0 +1,6 @@
+export * from './onConnectionError';
+
+export * from './onClientDisconnected';
+export * from './onClientBanned';
+
+export * from './onSessionStateChange';

package/src/client/events/onClientBanned.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onClientBanned } from '@amityco/ts-sdk-react-native'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onClientBanned = (callback: Amity.Listener<Amity.UserPayload>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(
+    client,
+    `client/onConnectionError(user.didGlobalBan)`,
+    'user.didGlobalBan',
+    callback,
+  );
+};

package/src/client/events/onClientDisconnected.ts

@@ -0,0 +1,22 @@
+import { onConnectionError } from './onConnectionError';
+
+/**
+ * ```js
+ * import { onClientDisconnected } from '@amityco/ts-sdk-react-native'
+ * const dispose = onClientDisconnected(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been disconnected
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onClientDisconnected = (callback: Amity.Listener<void>): Amity.Unsubscriber => {
+  return onConnectionError(({ code }) => {
+    code === Amity.ClientError.DISCONNECTED && callback();
+  });
+};

package/src/client/events/onConnectionError.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+import { ASCError, ASCConnectionError } from '~/core/errors';
+
+const EVENTS = [
+  'disconnected',
+  'error',
+  'connect_error',
+  'reconnect_error',
+  'reconnect_failed',
+] as const;
+
+/**
+ * ```js
+ * import { onConnectionError } from '@amityco/ts-sdk-react-native'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onConnectionError = (callback: Amity.Listener<ASCError>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const subscribers = EVENTS.map(event =>
+    createEventSubscriber(client, `client/onConnectionError(${event})`, event, response => {
+      const error = response?.code
+        ? new ASCError(response.message, response.code, Amity.ErrorLevel.FATAL)
+        : new ASCConnectionError(event);
+
+      callback(error);
+    }),
+  );
+
+  return () => {
+    subscribers.forEach(fn => fn());
+  };
+};

package/src/client/events/onSessionStateChange.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk-react-native'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onSessionStateChange = (
+  callback: Amity.Listener<Amity.SessionStates>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(
+    client,
+    `client/onSessionStateChange`,
+    'sessionStateChange',
+    callback,
+  );
+};

package/src/client/events/onTokenExpired.ts

@@ -0,0 +1,26 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onTokenExpired } from '@amityco/ts-sdk-react-native'
+ * const dispose = onTokenExpired((state: Amity.SessionStates.TOKEN_EXPIRED) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} session state has expired
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+export const onTokenExpired = (
+  callback: Amity.Listener<Amity.SessionStates.TOKEN_EXPIRED>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(client, `client/onTokenExpired`, 'tokenExpired', callback);
+};

package/src/client/events/onTokenTerminated.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ *
+ * Fired when any {@link Amity.Client} session state has terminated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+export const onTokenTerminated = (
+  callback: Amity.Listener<Amity.SessionStates.TERMINATED>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(client, `client/onTokenTerminated`, 'tokenTerminated', callback);
+};

package/src/client/events/tests/onSessionStateChange.test.ts

@@ -0,0 +1,37 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { onSessionStateChange } from '../onSessionStateChange';
+
+describe('onSessionStateChange', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should call callback on event', () => {
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.ESTABLISHED;
+
+    const unsub = onSessionStateChange(callback);
+    client.emitter.emit('sessionStateChange', expected);
+
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not call callback if unsubscribed', () => {
+    const callback = jest.fn();
+    const state = Amity.SessionStates.ESTABLISHED;
+
+    const unsub = onSessionStateChange(callback);
+    unsub();
+
+    client.emitter.emit('sessionStateChange', state);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/client/events/tests/onTokenTerminated.test.ts

@@ -0,0 +1,37 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { onTokenTerminated } from '../onTokenTerminated';
+
+describe('onTokenTerminated', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should call callback on event', () => {
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.TERMINATED;
+
+    const unsub = onTokenTerminated(callback);
+    client.emitter.emit('tokenTerminated', expected);
+
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not call callback if unsubscribed', () => {
+    const callback = jest.fn();
+    const state = Amity.SessionStates.TERMINATED;
+
+    const unsub = onTokenTerminated(callback);
+    unsub();
+
+    client.emitter.emit('tokenTerminated', state);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/client/index.ts

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './events';
+export * from './observers';
+export * from './utils/markerSyncEngine';

package/src/client/observers/getTotalUnreadCount.ts

@@ -0,0 +1,41 @@
+import { ASCError } from '~/core/errors';
+import { getUserMarker } from '~/marker/api';
+import { onUserMarkerFetched } from '~/marker/events';
+import { liveObject } from '~/utils/liveObject';
+
+import { getActiveUser } from '../api';
+
+/**
+ * ```js
+ * import { getTotalUnreadCount } from '@amityco/ts-sdk-react-native';
+ *
+ * const unsubscribe = getTotalUnreadCount(response => {
+ *   totalUnreadCount = response.data;
+ * });
+ * ```
+ *
+ * Observe current user's unread count from {@link Amity.UserMarker}
+ *
+ * @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 events
+ *
+ * @category Message Live Object
+ */
+export const getTotalUnreadCount = (
+  callback: Amity.LiveObjectCallback<number>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const callbackDataSelector = (data: Amity.UserMarker | undefined) => data?.unreadCount ?? 0;
+
+  return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
+    callbackDataSelector,
+  });
+};

package/src/client/observers/index.ts

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

package/src/client/observers/tests/getTotalUnreadCount.test.ts

@@ -0,0 +1,101 @@
+import { getActiveUser, setActiveUser } from '~/client/api/activeUser';
+import { getTotalUnreadCount } from '~/client/observers';
+import { disableCache, enableCache } from '~/cache/api';
+import { pause, client, connectClient, disconnectClient, generateUserMarker } from '~/utils/tests';
+
+const refreshUpdateTime = <T extends ValueOf<Amity.Events>>(eventPayload: T): T => {
+  if (!eventPayload) return eventPayload;
+
+  // @ts-ignore
+  return Object.fromEntries(
+    Object.entries(eventPayload).map(([k, v]) => [
+      k,
+      v.map((model: Amity.Model) => ({
+        ...model,
+        updatedAt: Date.now(),
+      })),
+    ]),
+  );
+};
+
+const userId = 'user1';
+const userMarkerResponse = {
+  data: { userMarkers: [generateUserMarker({ userId, unreadCount: 0 })] },
+};
+
+describe('getTotalUnreadCount', () => {
+  beforeAll(async () => {
+    await connectClient();
+
+    // overwrite active userId with test id
+    setActiveUser({ ...getActiveUser(), _id: userId });
+  });
+
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.Events, ValueOf<Amity.Events>, any][] = [
+    [
+      'it should return correct payload on `onUserMarkerFetched`',
+      'local.userMarker.fetched',
+      {
+        userMarkers: [generateUserMarker({ userId, unreadCount: 2 })],
+      },
+      {
+        origin: 'event',
+        loading: false,
+        data: 2,
+      },
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, eventPayload, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(userMarkerResponse);
+
+    getTotalUnreadCount(callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    // on initial, expect 0 unread count
+    expect(callback).toHaveBeenLastCalledWith({
+      origin: 'server',
+      loading: false,
+      error: undefined,
+      data: 0,
+    });
+
+    client.emitter.emit(event, refreshUpdateTime(eventPayload));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenLastCalledWith(expected);
+  });
+
+  test('it should filter out duplicated callback', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(userMarkerResponse);
+
+    const eventPayload = {
+      userMarkers: [generateUserMarker({ userId, unreadCount: 2 })],
+    };
+
+    getTotalUnreadCount(callback);
+
+    await pause();
+
+    // initial callback
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // emit duplicated event
+    client.emitter.emit('local.userMarker.fetched', refreshUpdateTime(eventPayload));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+  });
+});

package/src/client/utils/endpoints.ts

@@ -0,0 +1,14 @@
+export const API_REGIONS = {
+  EU: 'eu',
+  SG: 'sg',
+  US: 'us',
+} as const;
+
+const URLS = {
+  http: 'https://api.{region}.amity.co',
+  mqtt: 'wss://sse.{region}.amity.co:443/mqtt',
+} as const;
+
+export function computeUrl(type: keyof typeof URLS, region: string) {
+  return URLS[type].replace('{region}', region);
+}

package/src/client/utils/index.ts

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