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

package/src/core/transports/http.ts

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

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

package/src/core/transports/mqtt.ts

@@ -0,0 +1,164 @@
+/* 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

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

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

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

package/src/eventRepository/api/createEvent.ts

@@ -0,0 +1,45 @@
+import { fireEvent } from '~/core/events';
+import { prepareEventPayload } from '../utils';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api/activeClient';
+import { eventLinkedObject } from '~/utils/linkedObject/eventLinkObject';
+
+/* begin_public_function
+  id: event.create
+*/
+/**
+ * ```js
+ * import { createEvent } from '@amityco/ts-sdk'
+ * const created = await createEvent(bundle)
+ * ```
+ *
+ * Creates an {@link Amity.Event}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Event}
+ * @returns The newly created {@link Amity.Event}
+ *
+ * @category Event API
+ * @async
+ */
+export const createEvent = async (
+  bundle: Amity.EventCreateOptions,
+): Promise<Amity.Cached<Amity.Event>> => {
+  const client = getActiveClient();
+  client.log('event/createEvent', bundle);
+
+  const { data: payload } = await client.http.post<Amity.EventPayload>('/api/v1/events', bundle);
+
+  const preparedPayload = prepareEventPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(preparedPayload, { cachedAt });
+
+  fireEvent('event.created', preparedPayload);
+
+  return {
+    data: eventLinkedObject(preparedPayload.events[0]),
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/eventRepository/api/index.ts

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

package/src/eventRepository/index.ts

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

package/src/eventRepository/utils/index.ts

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

package/src/eventRepository/utils/prepareEventPayload.ts

@@ -0,0 +1,10 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+export const prepareEventPayload = (
+  rawPayload: Amity.EventPayload,
+): Amity.ProcessedEventPayload => {
+  return {
+    ...rawPayload,
+    users: rawPayload.users.map(convertRawUserToInternalUser),
+  };
+};

package/src/external/api/createUserToken.ts

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

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

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

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

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