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

package/src/core/transports/mqtt.ts

@@ -0,0 +1,157 @@
+/* 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';
+
+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> {
+    if (mqttClient) {
+      mqttClient.removeAllListeners();
+      mqttClient.end(true);
+    }
+
+    mqttClient = mqtt.connect(
+      endpoint,
+      getMqttOptions({ username: params.userId, password: params.accessToken }),
+    );
+
+    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/v4/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/v4/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/transports/ws.ts

@@ -0,0 +1,60 @@
+import io from 'socket.io-client';
+import { unwrapPayload } from './utils';
+
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The socket.io server's URL
+ * @returns A pre-configured (non-connected) socket.io client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createWebsocketTransport = (endpoint: string) => {
+  const socket = io(endpoint, {
+    autoConnect: false,
+    reconnectionDelay: 2000,
+    transports: ['websocket'],
+  });
+
+  // FIXME: disconnectClient removes this listener and client can get global ban event
+  socket.on('disconnect', (reason: string) => {
+    if (reason === 'io server disconnect') socket.connect();
+  });
+
+  return socket;
+};
+
+/**
+ * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
+ *
+ * @param client The current client for which to send the event with
+ * @param event The websocket event name
+ * @param data The event's payload
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @async
+ * @hidden
+ */
+export const synchronousWSCall = async <T>(
+  client: Amity.Client,
+  event: string,
+  data?: Record<string, unknown>,
+) => {
+  const { ws } = client;
+
+  const value = await new Promise<T | undefined>((resolve, reject) => {
+    ws.emit(event, data, (response: Amity.Response<T>) => {
+      try {
+        resolve(unwrapPayload(response));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+
+  return value;
+};

package/src/core/uuid.ts

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

package/src/external/api/createUserToken.ts

@@ -0,0 +1,43 @@
+import { createHttpTransport } from '~/core/transports';
+import { getDeviceInfo, getDeviceId } 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.User['userId'];
+    displayName?: Amity.User['displayName'];
+    authToken?: string;
+  },
+) => {
+  const deviceId = getDeviceId();
+  const deviceInfo = getDeviceInfo();
+  const http = createHttpTransport(computeUrl('http', apiRegion));
+
+  const { data } = await http.post<Amity.Tokens>(
+    '/api/v4/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,29 @@
+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',
+      refreshToken: 'refreshToken',
+      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/getCustomRankingGlobalFeed.ts

@@ -0,0 +1,117 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: feed.query.custom_ranking_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk-react-native'
+ * const posts = await FeedRepository.getCustomRankingGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+export const getCustomRankingGlobalFeed = async (query?: {
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
+  const client = getActiveClient();
+  client.log('feed/getCustomRankingGlobalFeed', query);
+
+  const { page, ...params } = query ?? {};
+
+  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+    `/api/v5/me/global-feeds`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const { posts } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data);
+
+    const cacheKey = [
+      'customGlobalFeed',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: posts, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk-react-native'
+ * const posts = await FeedRepository.getCustomRankingGlobalFeed.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+getCustomRankingGlobalFeed.locally = (
+  query?: Parameters<typeof getCustomRankingGlobalFeed>[0],
+): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getCustomRankingGlobalFeed.locally', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query ?? {};
+
+  const queryKey = [
+    'customGlobalFeed',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+  const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {};
+
+  if (!data?.posts.length) return;
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/feedRepository/api/index.ts

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

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -0,0 +1,126 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: feed.query.global_feed
+*/
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk-react-native'
+ * const posts = await queryGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+export const queryGlobalFeed = async (query?: {
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  useCustomRanking?: boolean;
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
+  const client = getActiveClient();
+  client.log('feed/queryGlobalFeed', query);
+
+  const { useCustomRanking, page, ...params } = query ?? {};
+
+  /*
+   * TODO: Remove useCustomRanking key from query
+   */
+  if (useCustomRanking)
+    console.warn(
+      'The param "useCustomRanking" has been deprecated. To get custom ranking feed use FeedRepository.getCustomRankingGlobalFeed instead',
+    );
+
+  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+    `/api/v4/me/global-feeds`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const { posts } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data);
+
+    const cacheKey = [
+      'globalFeed',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: posts, cachedAt, prevPage, nextPage };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk-react-native'
+ * const posts = await queryGlobalFeed.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+queryGlobalFeed.locally = (
+  query?: Parameters<typeof queryGlobalFeed>[0],
+): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
+  const client = getActiveClient();
+  client.log('post/queryGlobalFeed.locally', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query ?? {};
+
+  const queryKey = [
+    'globalFeed',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+  const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {};
+
+  if (!data?.posts.length) return;
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined;
+};