@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

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

@@ -0,0 +1,164 @@
+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, pause, emptyPostPayload } 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', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  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', () => {
+    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,
+    });
+  });
+
+  test('should call callback with server data for invalid cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        ...emptyPostPayload,
+        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,
+      }),
+    );
+  });
+
+  test('should execute mutators optimistically', () => {
+    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();
+  });
+
+  /*
+   * 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', () => {
+    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/v5/messages/${deletingMsgId}`);
+  });
+
+  test('should throw error if optimistic execution fails', async () => {
+    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,
+    });
+  });
+
+  test('should return error if call to server fails', async () => {
+    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);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, {
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+    expect(callback).toHaveBeenNthCalledWith(2, {
+      origin: 'server',
+      loading: false,
+      error: expect.any(Error),
+    });
+  });
+});

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/tests/subscription.test.ts

@@ -0,0 +1,93 @@
+import { ASCUnknownError } from '~/core/errors';
+import { connectClient, disconnectClient, client } from '~/utils/tests';
+
+import { getChannelTopic, getMessageTopic, subscribeTopic } from '../subscription';
+
+describe('getTopic', () => {
+  test('should generate channel topic', () => {
+    const channel = { path: 'channel-path' };
+
+    expect(getChannelTopic(channel)).toEqual('channel-path/#');
+  });
+
+  test('should generate channel topic', () => {
+    const message = { path: 'message-path' };
+
+    expect(getMessageTopic(message)).toEqual('message-path');
+  });
+});
+
+describe('subscription', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const channel = { path: 'channel-path' };
+
+  // integration_test_id: cb1b5450-b131-4a00-9c47-aad26f415b20
+  test('it should return succesfull result for valid topic', () => {
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => () => null);
+
+    const recieved = subscribeTopic(getChannelTopic(channel), () => null);
+
+    expect(recieved).toBeTruthy();
+  });
+
+  // integration_test_id: 09db1790-08e1-43d2-a674-866c5dd3c75c
+  test('it should return 800000 for subscribing to invalid topid', () => {
+    const expected = new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => () => {
+      throw expected;
+    });
+
+    try {
+      subscribeTopic('invalid topic', () => null);
+    } catch (error) {
+      expect(error).toEqual(expected);
+    }
+  });
+
+  test('it should call mqtt connect if accesstoken does not match', () => {
+    const callback = jest.fn();
+
+    client.token = { accessToken: '', issuedAt: '', expiresAt: '' };
+    client.mqtt.connect = callback;
+
+    subscribeTopic(getChannelTopic(channel), () => null);
+
+    expect(callback).toHaveBeenCalled();
+  });
+});
+
+describe('unsubsribe', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const channel = { path: 'channel-path' };
+
+  // integration_test_id: 87978499-5f4e-4a36-a092-56dde566329a
+  test('it should succesfully call unsubsribe', () => {
+    client.mqtt.unsubscribe = jest.fn().mockImplementation(() => true);
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => client.mqtt.unsubscribe);
+
+    const recieved = subscribeTopic(getChannelTopic(channel), () => null);
+
+    expect(recieved()).toEqual(true);
+  });
+
+  // integration_test_id: 8d444682-453d-44f8-b8c1-8c282e7db4bc
+  test('it should throw error', () => {
+    const expected = new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
+    client.mqtt.unsubscribe = jest.fn().mockImplementation(() => {
+      throw expected;
+    });
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => client.mqtt.unsubscribe);
+
+    try {
+      const recieved = subscribeTopic('invalid topic', () => null);
+
+      recieved();
+    } catch (error) {
+      expect(error).toEqual(expected);
+    }
+  });
+});

package/src/core/transports/http.ts

@@ -1,30 +1,10 @@
 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}`;
-      }
+import { ASCError } from '~/core/errors';
 
-      // @ts-ignore
-      return stringify(value, prefix ?? name);
-    })
-    .join('&');
-};
+import { fireEvent } from '../events';
+import { unwrapPayload } from './utils';
 
 /**
  * Creates a pre-configured axios instance
@@ -47,17 +27,67 @@ export const createHttpTransport = (endpoint: string) => {
     baseURL: endpoint,
     httpAgent: new HttpAgent(options),
     httpsAgent: new HttpsAgent(options),
-    paramsSerializer: stringify,
+    /*
+     * 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.interceptors.request.use(config => {
+    // do not check expiration for token creation url
+    if (config.url === '/api/v4/sessions') {
+      return config;
+    }
+
+    // check global.ts for the extension of AxiosRequestConfig
+    const tokenExpiry = config.metadata?.tokenExpiry;
+
+    if (tokenExpiry) {
+      if (Date.now() >= Date.parse(tokenExpiry)) {
+        return {
+          ...config,
+          cancelToken: new axios.CancelToken(cancel => cancel('Token Expired')),
+        };
+      }
+    }
+
+    return config;
   });
 
   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);
+      // handle unauthorized request
+      if (response.data.code === Amity.ServerError.UNAUTHORIZED) {
+        fireEvent('tokenTerminated', Amity.SessionStates.TERMINATED);
+      }
+
+      // handle request cancellation
+      if (axios.isCancel(error)) {
+        fireEvent('tokenExpired', Amity.SessionStates.TOKEN_EXPIRED);
+
+        throw new ASCError(
+          'Token expired',
+          Amity.ClientError.TOKEN_EXPIRED,
+          Amity.ErrorLevel.FATAL,
+        );
+      }
+
+      // if it's an error with status in the response payload,
+      // then it's an expected error.
+      if (response?.data?.status) {
+        unwrapPayload(response?.data);
+      }
+      // unexpected error.
+      else {
+        throw new Error(response?.data ?? error);
+      }
     },
   );
 

package/src/core/transports/mqtt.ts

@@ -21,7 +21,7 @@ export function getMqttOptions(params: {
 }): IClientOptions {
   return {
     clean: false, // keep subscriptions
-    clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
+    clientId: `mqttjs_ + ${Math.random().toString(16).substring(2, 10)}`,
     protocolId: 'MQTT',
     protocolVersion: 4,
     reconnectPeriod: 0, // disable auto reconnect

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

@@ -0,0 +1,84 @@
+import nock from 'nock';
+
+import { ASCApiError, ASCUnknownError } from '~/core/errors';
+import { createFileFormData } from '~/utils/tests';
+
+import { getPastDate } from '~/core/model';
+import { createHttpTransport } 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() };
+
+      const expected = expect.objectContaining({ data: expectedResolveValue });
+      await expect(instance.get('/api/v4/sessions')).resolves.toEqual(expected);
+    });
+  });
+});

package/src/external/api/createUserToken.ts

@@ -26,11 +26,11 @@ export const createUserToken = async (
   },
 ) => {
   const deviceId = getDeviceId();
-  const deviceInfo = await getDeviceInfo();
+  const deviceInfo = getDeviceInfo();
   const http = createHttpTransport(computeUrl('http', apiRegion));
 
   const { data } = await http.post<Amity.Tokens>(
-    '/api/v3/sessions',
+    '/api/v4/sessions',
     {
       ...params,
       deviceId,

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/feed/api/queryGlobalFeed.ts

@@ -4,7 +4,11 @@ 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'
@@ -29,7 +33,7 @@ export const queryGlobalFeed = async (query?: {
 
   const { useCustomRanking, page, ...params } = query ?? {};
 
-  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
     useCustomRanking ? `/api/v5/me/global-feeds` : `/api/v4/me/global-feeds`,
     {
       params: {
@@ -41,13 +45,16 @@ export const queryGlobalFeed = async (query?: {
     },
   );
 
-  const { paging, ...payload } = data;
-  const { posts } = payload;
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const { posts } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.PostPayload);
+    ingestInCache(data);
 
     const cacheKey = [
       'globalFeed',
@@ -62,6 +69,7 @@ export const queryGlobalFeed = async (query?: {
 
   return { data: posts, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -78,7 +86,7 @@ export const queryGlobalFeed = async (query?: {
  * @async
  * */
 queryGlobalFeed.locally = (
-  query: Parameters<typeof queryGlobalFeed>[0],
+  query?: Parameters<typeof queryGlobalFeed>[0],
 ): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
   const client = getActiveClient();
   client.log('post/queryGlobalFeed.locally', query);