@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/core/transports/http.ts

@@ -1,197 +0,0 @@
-import axios, { AxiosResponse } from 'axios';
-import HttpAgent, { HttpsAgent } from 'agentkeepalive';
-
-import { ASCError } from '~/core/errors';
-
-import { fireEvent } from '../events';
-import { unwrapPayload } from './utils';
-import NetworkActivitiesWatcher from '~/client/utils/NetworkActivitiesWatcher';
-
-/*
- * Defined here as transport is a private module. Also, outside of this module
- * this enum holds no meaning.
- *
- * @private (exported for testing)
- */
-export enum RequestCancelation {
-  UserDeleted = 'User Deleted',
-  UserGlobalBanned = 'User Global Banned',
-  TokenExpired = 'Token Expired',
-}
-/*
- * Axios no longer supports `cancelToken`, since v0.22.0, and is marked as
- * deprecated. The doc asks to use the abort controller that fetch uses instead
- *
- * More Info:
- * https://axios-http.com/docs/cancellation
- */
-const controller = new AbortController();
-
-/**
- * Handle Request Cancellation
- *
- * @param cancel Reason for cancelation
- *
- * @category Transport Util
- * @hidden
- */
-const handleRequestCancelation = (cancel: RequestCancelation) => {
-  switch (cancel) {
-    case RequestCancelation.UserGlobalBanned:
-      /*
-       * Note:
-       * Firing a virtual event (fireEvent) is not required as the metadata in
-       * the request (isGlobalBanned) is only true once the user has been banned
-       * and the SDK has recieved a global ban event
-       */
-      throw new ASCError(cancel, Amity.ServerError.GLOBAL_BAN, Amity.ErrorLevel.FATAL);
-
-    case RequestCancelation.UserDeleted:
-      /*
-       * Note:
-       * Firing a virtual event (fireEvent) is not required. For same reason as
-       * above. Only difference is that the event recieved is user deleted
-       */
-      throw new ASCError(cancel, Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL);
-
-    case RequestCancelation.TokenExpired:
-      fireEvent('tokenExpired', Amity.SessionStates.TOKEN_EXPIRED);
-
-      throw new ASCError(cancel, Amity.ClientError.TOKEN_EXPIRED, Amity.ErrorLevel.FATAL);
-
-    default:
-      throw new ASCError(
-        'Request Aborted',
-        Amity.ClientError.UNKNOWN_ERROR,
-        Amity.ErrorLevel.ERROR,
-      );
-  }
-};
-
-/**
- * Creates a pre-configured axios instance
- *
- * @param endpoint The ASC rest api server's URL
- * @returns A pre-configured axios instance
- *
- * @category Transport
- * @hidden
- */
-export const createHttpTransport = (endpoint: string) => {
-  const options = {
-    maxSockets: 100,
-    maxFreeSockets: 10,
-    timeout: 60000,
-    freeSocketTimeout: 30000,
-  };
-
-  const instance = axios.create({
-    baseURL: endpoint,
-    httpAgent: new HttpAgent(options),
-    httpsAgent: new HttpsAgent(options),
-    signal: controller.signal,
-    /*
-     * If paramSerializer is required, use the serialize option to stringify
-     * params. The encode option will pass complex params as string only whereas
-     * the serialize option will pass params in the format Record<string, any>
-     *
-     * For more details:
-     * https://github.com/axios/axios#request-config
-     */
-  });
-
-  instance.defaults.withCredentials = false;
-
-  instance.interceptors.request.use(config => {
-    // do not check expiration for token creation url
-
-    if (config.url === '/api/v5/sessions') {
-      return config;
-    }
-
-    // check global.ts for the extension of AxiosRequestConfig
-    if (config.metadata) {
-      const { tokenExpiry, isGlobalBanned, isUserDeleted } = config.metadata;
-
-      if (isGlobalBanned) {
-        controller.abort();
-        handleRequestCancelation(RequestCancelation.UserGlobalBanned);
-      }
-
-      if (isUserDeleted) {
-        controller.abort();
-        handleRequestCancelation(RequestCancelation.UserDeleted);
-      }
-
-      if (tokenExpiry) {
-        // if (Date.now() >= Date.parse(tokenExpiry)) {
-        //   controller.abort(RequestCancelation.UserDeleted);
-        //   handleRequestCancelation(RequestCancelation.TokenExpired);
-        // }
-      }
-    }
-
-    return config;
-  });
-
-  instance.interceptors.response.use(
-    response => {
-      const responseHeaders = new Headers();
-
-      Object.entries(response.headers).forEach(([key, value]) => {
-        if (typeof value === 'string') {
-          responseHeaders.append(key, value);
-        }
-      });
-
-      const url = (response.config.baseURL || '') + (response.config.url || '');
-      const method = response.config.method?.toUpperCase();
-
-      const requestInit: RequestInit = {
-        method,
-        headers: response.config.headers,
-      };
-
-      if (method !== 'GET' && method !== 'HEAD') {
-        requestInit.body = response.config.data;
-      }
-
-      NetworkActivitiesWatcher.getInstance().setNetworkActivities(new Request(url, requestInit), {
-        data: response.data,
-        status: response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-      });
-
-      return response;
-    },
-    error => {
-      const { response } = error;
-
-      // handle unauthorized request
-      if (response?.data.code === Amity.ServerError.UNAUTHORIZED) {
-        fireEvent('tokenTerminated', Amity.SessionStates.TERMINATED);
-      }
-
-      // if it's an error with status in the response payload,
-      // then it's an expected error.
-      if (response?.data?.status) {
-        unwrapPayload(response?.data);
-      }
-
-      // as on request cancellation error is returned
-      if (controller.signal.aborted) {
-        throw error;
-      }
-      // unexpected error.
-
-      throw new Error(response?.data ?? error);
-    },
-  );
-
-  instance.defaults.paramsSerializer = {
-    encode: params => encodeURIComponent(params),
-  };
-
-  return instance;
-};

package/src/core/transports/index.ts

@@ -1,2 +0,0 @@
-export * from './http';
-export * from './mqtt';

package/src/core/transports/mqtt.ts

@@ -1,164 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable no-promise-executor-return */
-import mqtt, { IClientOptions, ISubscriptionGrant, MqttClient } from 'mqtt/dist/mqtt';
-import { subscribeGlobalTopic } from '~/client/utils/subscribeGlobalTopic';
-import { ASCError, ASCUnknownError } from '~/core/errors';
-import { getMQTTClientId } from '~/core/device';
-
-const QOS_FAILURE_CODE = 128;
-
-const RETRY_BASE_TIMEOUT = 1000;
-const RETRY_MAX_TIMEOUT = 8000;
-
-const enum MqttError {
-  IDENTIFIER_REJECTED = 2,
-  BAD_USERNAME_OR_PASSWORD = 134,
-  NOT_AUTHORIZED = 135,
-}
-
-export function getMqttOptions(params: {
-  username: string;
-  password: string;
-  clientId?: string;
-}): IClientOptions {
-  return {
-    clean: false, // keep subscriptions
-    clientId: `mqttjs_ + ${Math.random().toString(16).substring(2, 10)}`,
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    reconnectPeriod: RETRY_BASE_TIMEOUT,
-    will: {
-      topic: 'WillMsg',
-      payload: 'Connection Closed abnormally..!',
-      qos: 0,
-      retain: false,
-    },
-    resubscribe: true,
-
-    ...params,
-  };
-}
-
-/**
- * Creates a pre-configured socket.io instance
- *
- * @param endpoint The mqtt server's URL
- * @returns A pre-configured (non-connected) mqtt client instance
- *
- * @category Transport
- * @hidden
- */
-export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
-  let mqttClient: MqttClient;
-
-  async function connect(params: { accessToken: string; userId: string }): Promise<void> {
-    const clientId = await getMQTTClientId(params.userId);
-
-    if (mqttClient) {
-      mqttClient.removeAllListeners();
-      mqttClient.end(true);
-    }
-
-    mqttClient = mqtt.connect(
-      endpoint,
-      getMqttOptions({
-        username: params.userId,
-        password: params.accessToken,
-        clientId,
-      }),
-    );
-
-    mqttClient.on('connect', () => {
-      mqttClient.options.reconnectPeriod = RETRY_BASE_TIMEOUT;
-
-      subscribeGlobalTopic();
-    });
-
-    mqttClient.on('error', (error: Error & { code: number }) => {
-      // eslint-disable-next-line default-case
-      switch (error.code) {
-        case MqttError.IDENTIFIER_REJECTED:
-        case MqttError.BAD_USERNAME_OR_PASSWORD:
-        case MqttError.NOT_AUTHORIZED:
-          mqttClient.end();
-      }
-    });
-
-    mqttClient.on('reconnect', () => {
-      // Double the reconnect period for each attempt
-      mqttClient.options.reconnectPeriod = Math.min(
-        (mqttClient.options.reconnectPeriod || RETRY_BASE_TIMEOUT) * 2,
-        RETRY_MAX_TIMEOUT,
-      );
-    });
-
-    return new Promise(resolve => mqttClient!.once('connect', () => resolve()));
-  }
-
-  return {
-    connect,
-    async disconnect(): Promise<void> {
-      if (this.connected) {
-        return new Promise(resolve => mqttClient?.end(true, undefined, () => resolve()));
-      }
-    },
-    get connected() {
-      return !!mqttClient?.connected;
-    },
-    on<T extends keyof Amity.MqttEvents>(
-      event: T,
-      handler: (payload: Amity.MqttEvents[T]) => void,
-    ) {
-      mqttClient?.on(event, handler);
-    },
-    once<T extends keyof Amity.MqttEvents>(
-      event: T,
-      handler: (payload: Amity.MqttEvents[T]) => void,
-    ) {
-      mqttClient?.once(event, handler);
-    },
-    off<T extends keyof Amity.MqttEvents>(
-      event: T,
-      handler?: (payload: Amity.MqttEvents[T]) => void,
-    ) {
-      if (handler !== undefined) {
-        mqttClient?.off(event, handler);
-      } else {
-        mqttClient?.removeAllListeners(event);
-      }
-    },
-    removeAllListeners() {
-      mqttClient?.removeAllListeners();
-    },
-    subscribe(topic: string, callback?: Amity.Listener<ASCError | void>): Amity.Unsubscriber {
-      const callbackWrapper = (error: Error, granted: ISubscriptionGrant[]) => {
-        // In MQTT.js, when you subscribe to a topic with QoS 0, the granted parameter
-        // in the callback will typically be empty or undefined
-        if (error || granted[0]?.qos === QOS_FAILURE_CODE) {
-          const ascError = error
-            ? new ASCError(error.message, Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR)
-            : // TODO throw the actual error, once BE can tell us the actual error code
-              new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
-
-          // Use warning lv instead of error lv to prevent misunderstanding of user
-          console.warn(`Failed to subscribe to topic ${topic}`, ascError);
-          callback?.(ascError);
-        } else {
-          console.log(`Subscribed to topic ${topic}`);
-          callback?.();
-        }
-      };
-
-      if (mqttClient) {
-        mqttClient.subscribe(topic, { qos: 0 }, callbackWrapper);
-      } else {
-        callbackWrapper(new Error('No connection to broker'), []);
-      }
-
-      return () => mqttClient?.unsubscribe(topic);
-    },
-    unsubscribe(topic: string) {
-      mqttClient?.unsubscribe(topic);
-    },
-  };
-};

package/src/core/transports/tests/http.test.ts

@@ -1,122 +0,0 @@
-import nock from 'nock';
-
-import { ASCApiError, ASCUnknownError, ASCError } from '~/core/errors';
-import { createFileFormData } from '~/utils/tests';
-
-import { getPastDate, getFutureDate } from '~/core/model';
-import { createHttpTransport, RequestCancelation } from '../http';
-
-const baseUrl = 'https://non-exist.domain';
-
-describe('core/transports', () => {
-  describe('createHttpTransport', () => {
-    beforeAll(nock.disableNetConnect);
-    beforeEach(nock.cleanAll);
-
-    test('should create axios instance with out error', () => {
-      nock(baseUrl).get(/./).reply(200);
-
-      expect(createHttpTransport(baseUrl)).not.toThrow();
-    });
-
-    test('instance should resolved http request', async () => {
-      const expectedResolveValue = { foo: 'bar' };
-      nock(baseUrl).get('/foo').reply(200, expectedResolveValue);
-
-      const instance = createHttpTransport(baseUrl);
-
-      const expected = expect.objectContaining({ data: expectedResolveValue });
-      await expect(instance.get('/foo')).resolves.toEqual(expected);
-    });
-
-    test('instance should throw Error when got 400 response code', async () => {
-      nock(baseUrl).get('/foo').reply(400);
-
-      const instance = createHttpTransport(baseUrl);
-
-      await expect(instance.get('/foo')).rejects.toThrow(Error);
-    });
-
-    test('instance should throw Error when got 500 response code', async () => {
-      nock(baseUrl).get('/foo').reply(500);
-
-      const instance = createHttpTransport(baseUrl);
-
-      await expect(instance.get('/foo')).rejects.toThrow(Error);
-    });
-
-    test('instance should throw `ASCUnknownError` when got `fail` status in payload', async () => {
-      nock(baseUrl).get('/foo').reply(500, { status: 'fail', message: 'something fail' });
-
-      const instance = createHttpTransport(baseUrl);
-
-      await expect(instance.get('/foo')).rejects.toThrow(ASCUnknownError);
-    });
-
-    test('instance should throw `ASCApiError` when got `error` status in payload', async () => {
-      nock(baseUrl).get('/foo').reply(500, { status: 'error', message: 'something error' });
-
-      const instance = createHttpTransport(baseUrl);
-
-      await expect(instance.get('/foo')).rejects.toThrow(ASCApiError);
-    });
-
-    test('instance should receive formData', async () => {
-      const formData = createFileFormData();
-      nock(baseUrl).post('/foo').reply(200);
-
-      const instance = createHttpTransport(baseUrl);
-
-      await expect(instance.post('/foo', formData)).resolves.not.toThrow();
-    });
-
-    test('should not check token expiration for token creation url', async () => {
-      const expectedResolveValue = { foo: 'bar' };
-      nock(baseUrl).get('/api/v5/sessions').reply(200, expectedResolveValue);
-
-      const instance = createHttpTransport(baseUrl);
-      instance.defaults.metadata = {
-        tokenExpiry: getPastDate(),
-        isGlobalBanned: false,
-        isUserDeleted: false,
-      };
-
-      const expected = expect.objectContaining({ data: expectedResolveValue });
-      await expect(instance.get('/api/v5/sessions')).resolves.toEqual(expected);
-    });
-
-    test('it should throw error is user is global banned', async () => {
-      const err = new ASCError(
-        RequestCancelation.UserGlobalBanned,
-        Amity.ServerError.GLOBAL_BAN,
-        Amity.ErrorLevel.FATAL,
-      );
-
-      const instance = createHttpTransport(baseUrl);
-      instance.defaults.metadata = {
-        tokenExpiry: getFutureDate(),
-        isGlobalBanned: true,
-        isUserDeleted: false,
-      };
-
-      await expect(instance.get('/foo')).rejects.toThrow(err);
-    });
-
-    test('it should throw error is user is deleted', async () => {
-      const err = new ASCError(
-        RequestCancelation.UserDeleted,
-        Amity.ServerError.UNAUTHORIZED,
-        Amity.ErrorLevel.FATAL,
-      );
-
-      const instance = createHttpTransport(baseUrl);
-      instance.defaults.metadata = {
-        tokenExpiry: getFutureDate(),
-        isGlobalBanned: false,
-        isUserDeleted: true,
-      };
-
-      await expect(instance.get('/foo')).rejects.toThrow(err);
-    });
-  });
-});

package/src/core/transports/utils.ts

@@ -1,26 +0,0 @@
-import { ASCApiError, ASCUnknownError } from '~/core/errors';
-
-/**
- * Unwraps v3 server payload (for error handling and type extraction)
- *
- * @param response A typical "v3" response (related to backend's service strategy)
- *
- * @returns The data returned by the backend
- * @throws An error related to backend's rejection
- *
- * @category Transport
- * @hidden
- */
-export const unwrapPayload = <T>(response: Amity.Response<T>): T => {
-  if (response.status === 'success') {
-    return response.data;
-  }
-  if (response.status === 'fail') {
-    throw new ASCUnknownError(response.code);
-  } else if (response.status === 'error') {
-    throw new ASCApiError(response.message, response.code, Amity.ErrorLevel.ERROR);
-  }
-
-  // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
-  return undefined as unknown as T;
-};

package/src/core/uuid.ts

@@ -1,3 +0,0 @@
-import nativeIdGenerator from 'react-native-uuid';
-
-export const uuid = () => nativeIdGenerator.v4().toString();

package/src/external/api/createUserToken.ts

@@ -1,43 +0,0 @@
-import { createHttpTransport } from '~/core/transports';
-import { getDeviceId, getDeviceInfo } from '~/core/device';
-import { API_REGIONS, computeUrl } from '~/client/utils/endpoints';
-
-/**
- * Retrieves accessToken info to use in Beta services
- *
- * @param apiKey for the Http Client instance
- * @param apiRegion endpoint to connect to
- * @param params The token parameters
- * @param params.userId The userId to use to issue a token
- * @param params.displayName The user's displayName
- * @param params.authToken The authentication token - necessary when network option is set to secure
- * @return An accessToken info object for the given userId
- *
- * @category External API
- * @hidden
- */
-export const createUserToken = async (
-  apiKey: string,
-  apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS],
-  params: {
-    userId: Amity.InternalUser['userId'];
-    displayName?: Amity.InternalUser['displayName'];
-    authToken?: string;
-  },
-) => {
-  const deviceId = await getDeviceId();
-  const deviceInfo = getDeviceInfo();
-  const http = createHttpTransport(computeUrl('http', apiRegion));
-
-  const { data } = await http.post<Amity.Tokens>(
-    '/api/v5/sessions',
-    {
-      ...params,
-      deviceId,
-      deviceInfo: { ...deviceInfo, model: 'token management API on TS-SDK' },
-    },
-    { headers: { 'X-API-Key': apiKey } },
-  );
-
-  return { accessToken: data.accessToken };
-};

package/src/external/api/index.ts

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

package/src/external/api/tests/createUserToken.test.ts

@@ -1,28 +0,0 @@
-import { getFutureDate } from '~/core/model';
-import { createHttpTransport } from '~/core/transports';
-import { createUserToken } from '../createUserToken';
-
-jest.mock('~/core/transports', () => ({
-  __esModule: true,
-  ...jest.requireActual('~/core/transports'),
-  createHttpTransport: jest.fn(),
-}));
-
-describe('createUserToken', () => {
-  // integration_test_id: 4771d3b9-1a05-4942-85e1-d2abea936c2f
-  it('should return a valid token', async () => {
-    const payload = {
-      accessToken: 'accessToken',
-      issuedAt: new Date().toISOString(),
-      expiresAt: getFutureDate(),
-    };
-    (createHttpTransport as jest.Mock).mockReturnValue({ post: () => ({ data: payload }) });
-
-    const { accessToken } = await createUserToken('apiKey', 'sg', {
-      userId: 'userId',
-      displayName: 'displayName',
-    });
-
-    expect(accessToken).toStrictEqual('accessToken');
-  });
-});

package/src/feedRepository/api/index.ts

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