@amityco/ts-sdk 0.0.1-beta.3 → 0.0.1-beta.30

package/src/core/tests/query/query/runQuery.test.ts

@@ -0,0 +1,182 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { runQuery, createQuery } from '~/core/query';
+import { createPost, getPost } from '~/post/api';
+import { deleteMessage } from '~/message/api';
+
+import { posts, client } from '~/utils/tests';
+
+const createPostArgs: Parameters<typeof createPost> = [
+  {
+    tags: ['a', 'b'],
+    data: {
+      text: 'hello!',
+    },
+    targetType: 'user',
+    targetId: 'userId1',
+  },
+];
+const post = { postId: posts.page1[0] };
+const deletingMsgId = 'deletingId';
+
+describe('Core/Query/runQuery', () => {
+  test('should call query with arguments', () => {
+    const createPostMock = jest.fn().mockResolvedValue('test');
+
+    const query = createQuery(createPostMock, createPostArgs);
+    runQuery(query);
+
+    expect(createPostMock).toBeCalledTimes(1);
+  });
+
+  test('should call callback with cache when valid', () => {
+    enableCache();
+
+    const callback = jest.fn();
+
+    const cachedAt = Date.now();
+    pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toBeCalled();
+    expect(callback).toBeCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt,
+      origin: 'local',
+      loading: false,
+      data: post,
+    });
+
+    disableCache();
+  });
+
+  test('should call callback with server data for invalid cache', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({ data: { posts: [post] } });
+
+    // at the time of writing this test, cache is valid for 2 minutes
+    const expiredDate = Date.parse('04 Dec 1995 00:12:00 GMT');
+    pushToCache(['post', 'get', post.postId], post, { cachedAt: expiredDate });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt: expiredDate,
+      origin: 'local',
+      loading: true,
+      data: post,
+    });
+
+    await expect(getPost(post.postId)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    // checking object containing as expiredAt cannot be predicted :D
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+        data: post,
+      }),
+    );
+
+    disableCache();
+  });
+
+  test('should execute mutators optimistically', () => {
+    enableCache();
+
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn();
+
+    const query = createQuery(createMessage);
+    runQuery(query);
+
+    expect(createMessage.optimistically).toHaveBeenCalled();
+    // should call server right after
+    expect(createMessage).toHaveBeenCalled();
+
+    disableCache();
+  });
+
+  /*
+   * NOTE: del not tested as the args are exactly the same as update
+   *
+   * Tested due to bug where optimistic args was modifying args for del &
+   * update when it does not need to
+   */
+  test('should not change args optimistically for update', () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValue(true);
+    // 'get', gets called after delete to verify delete
+    client.http.get = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query);
+
+    expect(client.http.delete).toHaveBeenCalledWith(`/api/v3/messages/${deletingMsgId}`);
+
+    disableCache();
+  });
+
+  test('should throw error if optimistic execution fails', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn().mockImplementation(() => {
+      throw new Error();
+    });
+
+    const query = createQuery(createMessage);
+    runQuery(query, callback);
+
+    expect(createMessage.optimistically).toThrow();
+    expect(callback).toBeCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    disableCache();
+  });
+
+  test('should return error if call to server fails', async () => {
+    enableCache();
+
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+    const callback = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    await expect(deleteMessage(deletingMsgId)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+      }),
+    );
+
+    disableCache();
+  });
+});

package/src/core/tests/query/query.test.ts

@@ -0,0 +1,101 @@
+import {
+  isFetcher,
+  isMutator,
+  isOffline,
+  isCachable,
+  isLocal,
+  isFresh,
+  queryOptions,
+} from '~/core/query';
+
+describe('Core/Query', () => {
+  type isFetcherMockType = jest.Mock<any, any> & {
+    locally?: jest.Mock<any, any>;
+  };
+
+  type isMutatorMockType = jest.Mock<any, any> & {
+    optimistically?: jest.Mock<any, any>;
+  };
+
+  describe('isFetcher', () => {
+    const isFetcherMock: isFetcherMockType = jest.fn();
+
+    test('should return false if func is not a fetcher', () => {
+      expect(isFetcher(isFetcherMock)).toBe(false);
+    });
+
+    test('should return true if func is a fetcher', () => {
+      isFetcherMock.locally = jest.fn();
+
+      expect(isFetcher(isFetcherMock)).toBe(true);
+    });
+  });
+
+  describe('isMutator', () => {
+    const isMutatorMock: isMutatorMockType = jest.fn();
+
+    test('should return false if func is not a mutator', () => {
+      expect(isMutator(isMutatorMock)).toBe(false);
+    });
+
+    test('should return true if func is a mutator', () => {
+      isMutatorMock.optimistically = jest.fn();
+
+      expect(isMutator(isMutatorMock)).toBe(true);
+    });
+  });
+
+  describe('isOffline', () => {
+    const isMutatorMock: isMutatorMockType = jest.fn();
+
+    test('should return false if func is not a mutator or fetcher', () => {
+      expect(isOffline(isMutatorMock)).toBe(false);
+    });
+
+    test('should return true if func is a mutator', () => {
+      isMutatorMock.optimistically = jest.fn();
+
+      expect(isMutator(isMutatorMock)).toBe(true);
+    });
+  });
+
+  describe('isCachable', () => {
+    test('should return false if object is not cachable', () => {
+      expect(isCachable({})).toBe(false);
+    });
+
+    test('should return true if object is cachable', () => {
+      expect(isCachable({ cachedAt: -1 })).toBe(true);
+    });
+  });
+
+  describe('isLocal', () => {
+    test('should return false if object is not local', () => {
+      expect(isLocal({ cachedAt: 0 })).toBe(false);
+    });
+
+    test('should return true if object is local', () => {
+      expect(isLocal({ cachedAt: -1 })).toBe(true);
+    });
+  });
+
+  describe('isFresh', () => {
+    test('should return false if object is not fresh', () => {
+      expect(isFresh({ cachedAt: -1 })).toBe(false);
+    });
+
+    test('should return true if object is fresh', () => {
+      expect(isFresh({ cachedAt: Date.now() })).toBe(true);
+    });
+  });
+
+  describe('queryOptions', () => {
+    test('should return lifespan 0 if server only', () => {
+      expect(queryOptions('server_only').lifeSpan).toBe(0);
+    });
+
+    test('should return lifespan Infinity if cache only', () => {
+      expect(queryOptions('cache_only').lifeSpan).toBe(Infinity);
+    });
+  });
+});

package/src/core/transports/http.ts

@@ -0,0 +1,65 @@
+import axios from 'axios';
+import HttpAgent, { HttpsAgent } from 'agentkeepalive';
+
+import { unwrapPayload } from './utils';
+
+/**
+ * Axios param serializer (for querystring)
+ * @hidden
+ */
+const stringify = (params: Record<string, unknown>, prefix?: string): string => {
+  return Object.entries(params)
+    .filter(([, value]) => value !== undefined)
+    .map(([name, value]) => {
+      const key = prefix ? `${prefix}[${name}]` : name;
+
+      if (Array.isArray(value)) {
+        return value.map(item => `${key}[]=${item}`).join('&');
+      }
+      if (typeof value !== 'object') {
+        return `${key}=${value}`;
+      }
+
+      // @ts-ignore
+      return stringify(value, prefix ?? name);
+    })
+    .join('&');
+};
+
+/**
+ * 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),
+    paramsSerializer: stringify,
+  });
+
+  instance.interceptors.response.use(
+    response => response,
+    error => {
+      const { response } = error;
+      // eslint-disable-next-line no-console
+      console.error(response?.data ?? error);
+
+      if (response) unwrapPayload(response.data);
+    },
+  );
+
+  return instance;
+};

package/src/core/transports/index.ts

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

package/src/core/transports/mqtt.ts

@@ -0,0 +1,160 @@
+/* eslint-disable no-console */
+/* eslint-disable no-promise-executor-return */
+import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from 'mqtt/dist/mqtt';
+import { ASCError, ASCUnknownError } from '~/core/errors';
+
+const QOS_FAILURE_CODE = 128;
+
+const RETRY_BASE_TIMEOUT = 1000;
+const RETRY_COUNT_MAX = 10;
+
+const enum MqttError {
+  IDENTIFIER_REJECTED = 2,
+  BAD_USERNAME_OR_PASSWORD = 4,
+  NOT_AUTHORIZED = 5,
+}
+
+export function getMqttOptions(params: {
+  username: string;
+  password: string;
+  clientId?: string;
+}): IClientOptions {
+  return {
+    clean: false, // keep subscriptions
+    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
+    protocolId: 'MQTT',
+    protocolVersion: 4,
+    reconnectPeriod: 0, // disable auto reconnect
+    will: {
+      topic: 'WillMsg',
+      payload: 'Connection Closed abnormally..!',
+      qos: 0,
+      retain: false,
+    },
+
+    ...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 | void;
+  let retryCount = 0;
+  let allowReconnection = true;
+
+  const reconnect = () => {
+    setTimeout(() => {
+      retryCount += 1;
+      mqttClient!.reconnect();
+    }, RETRY_BASE_TIMEOUT * 2 ** (retryCount > RETRY_COUNT_MAX ? RETRY_COUNT_MAX : retryCount));
+  };
+
+  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', () => {
+      retryCount = 0;
+      allowReconnection = true;
+    });
+
+    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:
+          allowReconnection = false;
+      }
+    });
+
+    mqttClient.on('close', () => {
+      if (allowReconnection) {
+        reconnect();
+      }
+    });
+
+    return new Promise(resolve => mqttClient!.once('connect', () => resolve()));
+  }
+
+  return {
+    connect,
+    async disconnect(): Promise<void> {
+      allowReconnection = false;
+
+      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[]) => {
+        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);
+
+          console.error(`Failed to subscribe to topic ${topic}`, ascError);
+          callback?.(ascError);
+        } else {
+          console.log(`Subscribed to topic ${granted[0].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/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

@@ -1,2 +1,3 @@
-import nativeIdGenerator from 'react-native-uuid'
-export const uuid = () => nativeIdGenerator.v4().toString()
+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 = await getDeviceInfo();
+  const http = createHttpTransport(computeUrl('http', apiRegion));
+
+  const { data } = await http.post<Amity.Tokens>(
+    '/api/v3/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/feed/api/index.ts

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