@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-bef76fa.0

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,111 @@
+import {
+  isFetcher,
+  isMutator,
+  isOffline,
+  isCachable,
+  isLocal,
+  isFresh,
+  queryOptions,
+} from '~/core/query';
+import { CACHE_LIFESPAN } from '~/cache/utils';
+
+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 minimum lifeSpan', () => {
+      expect(queryOptions('cache_then_server').lifeSpan).toBe(CACHE_LIFESPAN);
+    });
+
+    test('should return minimum lifeSpan if provided lifeSpan is less than cache lifeSpan', () => {
+      expect(queryOptions('cache_then_server', 0).lifeSpan).toBe(CACHE_LIFESPAN);
+    });
+
+    test('should return provided lifeSpan if provided lifeSpan is more than cache lifeSpan', () => {
+      const value = CACHE_LIFESPAN * 2;
+      expect(queryOptions('cache_then_server', value).lifeSpan).toBe(value);
+    });
+
+    test('should return lifespan Infinity if cache only', () => {
+      expect(queryOptions('cache_only').lifeSpan).toBe(Infinity);
+    });
+  });
+});

package/src/core/transports/http.ts

@@ -1,28 +1,16 @@
-import axios from 'axios'
-import HttpAgent, { HttpsAgent } from 'agentkeepalive'
+import axios from 'axios';
+import qs from 'qs';
+import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 
-import { unwrapPayload } from './utils'
+import { unwrapPayload } from './utils';
 
 /**
  * Axios param serializer (for querystring)
  * @hidden
  */
-const stringify = (params: object, 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('&')
-      } else if (typeof value !== 'object') {
-        return `${key}=${value}`
-      }
-
-      return stringify(value, prefix ?? name)
-    })
-    .join('&')
-}
+export const stringify = (params: Record<string, unknown>): string => {
+  return qs.stringify(params, { arrayFormat: 'brackets' });
+};
 
 /**
  * Creates a pre-configured axios instance
@@ -39,25 +27,25 @@ export const createHttpTransport = (endpoint: string) => {
     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
-      console.error(response?.data ?? error)
-
-      if (response)
-        unwrapPayload(response.data)
-    }
-  )
-
-  return instance
-}
+    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/mqtt.ts

@@ -1,24 +1,39 @@
-import mqtt, { MqttClient, IClientOptions } from 'mqtt'
+/* 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';
 
-export function getMqttOptions(params: { username: string, password: string }): IClientOptions {
+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 {
-    keepalive: 30,
+    clean: false, // keep subscriptions
+    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
     protocolId: 'MQTT',
     protocolVersion: 4,
-    clean: true,
-    reconnectPeriod: 1000,
-    connectTimeout: 30 * 1000,
+    reconnectPeriod: 0, // disable auto reconnect
     will: {
       topic: 'WillMsg',
       payload: 'Connection Closed abnormally..!',
       qos: 0,
-      retain: false
+      retain: false,
     },
-    rejectUnauthorized: false,
 
-    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
-    ...params
-  }
+    ...params,
+  };
 }
 
 /**
@@ -31,45 +46,115 @@ export function getMqttOptions(params: { username: string, password: string }):
  * @hidden
  */
 export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
-  let mqttClient: MqttClient
+  let mqttClient: MqttClient | void;
+  let retryCount = 0;
+  let allowReconnection = true;
 
-  async function connect(params: { accessToken: string, userId: string }): Promise<void> {
-    mqttClient = mqtt.connect(endpoint, getMqttOptions({ username: params.userId, password: params.accessToken }))
+  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;
+      }
+    });
 
-    return new Promise(resolve => mqttClient.once('connect', () => resolve()))
+    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()))
+        return new Promise(resolve => mqttClient?.end(true, undefined, () => resolve()));
       }
     },
     get connected() {
-      return !!mqttClient?.connected
+      return !!mqttClient?.connected;
     },
-    on<T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) {
-      mqttClient.on(event, handler)
+    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.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) {
+    off<T extends keyof Amity.MqttEvents>(
+      event: T,
+      handler?: (payload: Amity.MqttEvents[T]) => void,
+    ) {
       if (handler !== undefined) {
-        mqttClient.off(event, handler)
+        mqttClient?.off(event, handler);
       } else {
-        mqttClient.removeAllListeners(event)
+        mqttClient?.removeAllListeners(event);
       }
     },
     removeAllListeners() {
-      mqttClient.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);
     },
-    subscribe(topic: string, handler?: (error: Error, granted: Object) => void) {
-      mqttClient.subscribe(topic, { qos: 0 }, handler)
+    unsubscribe(topic: string) {
+      mqttClient?.unsubscribe(topic);
     },
-    unsubscribe(topic: string, handler?: (payload: Object) => void) {
-      mqttClient.unsubscribe(topic, handler)
-    }
-  }
-}
+  };
+};

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

@@ -0,0 +1,83 @@
+import { createHttpTransport, stringify } from '../http';
+
+describe('core/transports', () => {
+  describe('stringify', () => {
+    test('should serializer simple string', () => {
+      const params = { a: 'c' };
+      const url = stringify(params);
+      expect(url).toBe('a=c');
+    });
+
+    test('should serializer empty string', () => {
+      const params = { a: '' };
+      const url = stringify(params);
+      expect(url).toBe('a=');
+    });
+
+    test('should serializer special character', () => {
+      const params = { a: '✓', b: 'ø' };
+      const url = stringify(params);
+      expect(url).toBe('a=%E2%9C%93&b=%C3%B8');
+    });
+
+    test('should serializer boolean', () => {
+      const params = { a: true, b: false };
+      const url = stringify(params);
+      expect(url).toBe('a=true&b=false');
+    });
+
+    test('should serializer null ', () => {
+      const params = { a: null };
+      const url = stringify(params);
+      expect(url).toBe('a=');
+    });
+
+    test('should serializer undefined', () => {
+      const params = { a: undefined };
+      const url = stringify(params);
+      expect(url).toBe('');
+    });
+
+    test('should serializer NaN', () => {
+      const params = { a: NaN };
+      const url = stringify(params);
+      expect(url).toBe('a=NaN');
+    });
+
+    test('should serializer simple array', () => {
+      const params = { a: ['b', 'c', 'd'] };
+      const url = stringify(params);
+      expect(url).toBe('a%5B%5D=b&a%5B%5D=c&a%5B%5D=d');
+    });
+
+    test('should serializer complex array', () => {
+      const params = { a: ['b', { c: 'd' }] };
+      const url = stringify(params);
+      expect(url).toBe('a%5B%5D=b&a%5B%5D%5Bc%5D=d');
+    });
+
+    test('should serializer nested object', () => {
+      const params = { a: { b: 'c' } };
+      const url = stringify(params);
+      expect(url).toBe('a%5Bb%5D=c');
+    });
+
+    test('should serializer deep nested object', () => {
+      const params = { a: { b: { c: { d: { e: { f: { g: { h: { i: 'j' } } } } } } } } };
+      const url = stringify(params);
+      expect(url).toBe('a%5Bb%5D%5Bc%5D%5Bd%5D%5Be%5D%5Bf%5D%5Bg%5D%5Bh%5D%5Bi%5D=j');
+    });
+
+    test('should serializer empty object', () => {
+      const params = { a: { b: [] } };
+      const url = stringify(params);
+      expect(url).toBe('');
+    });
+  });
+
+  describe('createHttpTransport', () => {
+    test('should create axios instance with out error', () => {
+      expect(createHttpTransport('/')).not.toThrow();
+    });
+  });
+});

package/src/core/transports/utils.ts

@@ -1,4 +1,4 @@
-import { ASCApiError, ASCUnknownError } from '~/core/errors'
+import { ASCApiError, ASCUnknownError } from '~/core/errors';
 
 /**
  * Unwraps v3 server payload (for error handling and type extraction)
@@ -13,13 +13,14 @@ import { ASCApiError, ASCUnknownError } from '~/core/errors'
  */
 export const unwrapPayload = <T>(response: Amity.Response<T>): T => {
   if (response.status === 'success') {
-    return response.data
-  } else if (response.status === 'fail') {
-    throw new ASCUnknownError(response.code)
+    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)
+    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
-}
+  return undefined as unknown as T;
+};