@amityco/ts-sdk 7.10.1-9fe9d33d.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,20 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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 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

@@ -1,36 +0,0 @@
-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 v5/sessions api', async () => {
-    const expected = '/api/v5/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

@@ -1,73 +0,0 @@
-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 = () =>
-  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

@@ -1,67 +0,0 @@
-import { pushToCache, pullFromCache, enableCache } from '~/cache/api';
-import { client, connectClient, message11 as message } from '~/utils/tests';
-
-import { logout } from '..';
-
-describe('logout', () => {
-  beforeEach(async () => {
-    await connectClient();
-  });
-
-  test('it should disconnect client', async () => {
-    const recieved = await logout();
-
-    expect(recieved).toBe(true);
-  });
-
-  test('it should set sesion state to notLoggedIn after disconnect', async () => {
-    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;
-
-    await logout();
-
-    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
-  });
-
-  test('it should clear userId and accessToken on disconnect', async () => {
-    await logout();
-
-    expect(client.userId).toBeUndefined();
-    expect(client.token).toBeUndefined();
-  });
-
-  test('it should clear auth header on disconnect', async () => {
-    await logout();
-
-    expect(client.http.defaults.headers.common.Authorization).toBeFalsy();
-  });
-
-  test('it should clear cache on disconnect', async () => {
-    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;
-
-    enableCache();
-
-    const cacheKey = ['message', 'get', message.messageId];
-    pushToCache(cacheKey, message);
-
-    await logout();
-
-    expect(pullFromCache(cacheKey)?.data).toStrictEqual(message);
-  });
-});

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

@@ -1,66 +0,0 @@
-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,
-    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/resumeSession.test.ts

@@ -1,164 +0,0 @@
-import { ASCApiError } from '~/core/errors';
-import { user11, disconnectClient } from '~/utils/tests';
-import { resumeSession, createClient } from '..';
-import { setActiveClient } from '../activeClient';
-
-let client: Amity.Client;
-
-const sessionHandler: Amity.SessionHandler = {
-  sessionWillRenewAccessToken(_) {
-    // do nothing
-  },
-};
-
-const mockToken = {
-  accessToken: 'mock-access-token',
-  issuedAt: '2023-01-01T00:00:00Z',
-  expiresAt: '2025-01-01T00:00:00Z',
-};
-
-const mockUserResponse = {
-  data: {
-    users: [user11],
-  },
-};
-
-const onConnect = () =>
-  describe('resumeSession', () => {
-    beforeEach(() => {
-      client = createClient('key', 'sg');
-      client.mqtt?.connect && (client.mqtt.connect = jest.fn());
-      client.mqtt?.subscribe && (client.mqtt.subscribe = jest.fn());
-      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
-
-      setActiveClient(client);
-    });
-
-    afterEach(async () => {
-      if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
-    });
-
-    test('it should connect client with access token', async () => {
-      onConnect().unref();
-
-      const received = await resumeSession(
-        { userId: user11.userId, token: mockToken },
-        sessionHandler,
-      );
-
-      expect(received).toBe(true);
-    });
-
-    test('it should establish connection', async () => {
-      onConnect().unref();
-
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-      const { sessionState } = client;
-
-      expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-    });
-
-    test('it should have session state establishing while connecting client', () => {
-      resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
-    });
-
-    test('it should have session state notLoggedIn on failure', async () => {
-      client.http.get = jest
-        .fn()
-        .mockRejectedValue(
-          new ASCApiError('unauthorized', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
-        );
-
-      await expect(
-        resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler),
-      ).rejects.toThrow('unauthorized');
-      expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
-    });
-
-    test('it should set authorization header with token', async () => {
-      onConnect().unref();
-
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      expect(client.http.defaults.headers.common.Authorization).toBe(
-        `Bearer ${mockToken.accessToken}`,
-      );
-      expect(client.upload.defaults.headers.common.Authorization).toBe(
-        `Bearer ${mockToken.accessToken}`,
-      );
-    });
-
-    test('it should set token metadata', async () => {
-      onConnect().unref();
-
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      expect(client.token).toEqual(mockToken);
-      expect(client.http.defaults.metadata).toEqual({
-        tokenExpiry: mockToken.expiresAt,
-        isGlobalBanned: false,
-        isUserDeleted: false,
-      });
-    });
-
-    test('it should call user endpoint to validate token', async () => {
-      onConnect().unref();
-
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      expect(client.http.get).toHaveBeenCalledWith(`/api/v3/users/${user11.userId}`);
-    });
-
-    test('it should terminate session on ban', async () => {
-      onConnect().unref();
-
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      // ban user
-      client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
-
-      expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
-    });
-
-    test('it should reset client state when user is already connected with same userId', async () => {
-      onConnect().unref();
-
-      // First connection
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-      expect(client.userId).toBe(user11.userId);
-
-      // Mock the HTTP call for second connection
-      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
-
-      // Second connection with same userId should treat as token expiry (preserve cache)
-      onConnect().unref();
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      // Verify that the client is properly reset and reconnected
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-      expect(client.userId).toBe(user11.userId);
-    });
-
-    test('it should preserve cache when resuming session with same userId', async () => {
-      onConnect().unref();
-
-      // First connection - set some cache data
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-      if (client.cache) {
-        client.cache.data = { test: 'data' };
-      }
-
-      // Mock the HTTP call for second connection
-      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
-
-      // Second connection with same userId
-      onConnect().unref();
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-
-      // Cache should be preserved when same userId is used
-      expect(client.cache?.data).toEqual({ test: 'data' });
-    });
-  });

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

@@ -1,62 +0,0 @@
-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

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

package/src/client/api/validateTexts.ts

@@ -1,23 +0,0 @@
-import { getActiveClient } from './activeClient';
-
-/**
- * Validate a list of texts
- * @param texts array of strings to validate (max 10 items)
- *
- * @category Client API
- */
-export const validateTexts = async (texts: string[]): Promise<boolean> => {
-  const client = getActiveClient();
-  client.log('channel/markerSync');
-
-  if (texts.length === 0) return false;
-
-  const { data: payload } = await client.http.post<{ success: boolean }>(
-    '/api/v3/blocklists/verify',
-    {
-      data: texts,
-    },
-  );
-
-  return payload.success;
-};

package/src/client/api/validateUrls.ts

@@ -1,23 +0,0 @@
-import { getActiveClient } from './activeClient';
-
-/**
- * Validate a list of urls
- * @param urls  array of strings to validate (max 10 items)
- *
- * @category Client API
- */
-export const validateUrls = async (urls: string[]): Promise<boolean> => {
-  const client = getActiveClient();
-  client.log('channel/markerSync');
-
-  if (urls.length === 0) return false;
-
-  const { data: payload } = await client.http.post<{ success: boolean }>(
-    '/api/v3/allowlists/verify',
-    {
-      data: urls,
-    },
-  );
-
-  return payload.success;
-};

package/src/client/events/index.ts

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

package/src/client/events/onClientBanned.ts

@@ -1,29 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { createEventSubscriber } from '~/core/events';
-
-/**
- * ```js
- * import { onClientBanned } from '@amityco/ts-sdk'
- * 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

@@ -1,22 +0,0 @@
-import { onConnectionError } from './onConnectionError';
-
-/**
- * ```js
- * import { onClientDisconnected } from '@amityco/ts-sdk'
- * 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();
-  });
-};