@amityco/ts-sdk 6.35.3-f8f74ab5.0 → 6.35.3

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

@@ -0,0 +1,180 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { createQuery, runQuery } from '~/core/query';
+import { createPost } from '~/postRepository/api';
+import { getPost } from '~/postRepository/api/getPost';
+import { softDeleteMessage } from '~/messageRepository/api';
+
+import { client, deepCopy, emptyPostPayload, pause, post11, user11 } from '~/utils/tests';
+
+const createPostArgs: Parameters<typeof createPost> = [
+  {
+    tags: ['a', 'b'],
+    data: {
+      text: 'hello!',
+    },
+    targetType: 'user',
+    targetId: 'userId1',
+  },
+];
+const post = post11;
+const deletingMsgId = 'deletingId';
+
+describe('Core/Query/runQuery', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  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 });
+    pushToCache(['user', 'get', user11.userId], user11);
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toBeCalled();
+    expect(callback).toBeCalledTimes(1);
+
+    expect(deepCopy(callback.mock.calls[0][0])).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          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 });
+    pushToCache(['user', 'get', user11.userId], user11);
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(deepCopy(callback.mock.calls[0][0])).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          cachedAt: expiredDate,
+          origin: 'local',
+          loading: true,
+          data: post,
+        }),
+      ),
+    );
+
+    await expect(getPost(post.postId)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    // checking an object containing as expiredAt cannot be predicted :D
+    expect(deepCopy(callback.mock.calls[1][0])).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          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(softDeleteMessage, 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(softDeleteMessage, 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/subscription.ts

@@ -0,0 +1,170 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { ASCError } from '~/core/errors';
+import { getActiveUser } from '~/client/api/activeUser';
+import { modifyMqttConnection } from '~/client/utils/modifyMqttConnection';
+
+export enum SubscriptionLevels {
+  COMMUNITY = 'community',
+  POST = 'post',
+  COMMENT = 'comment',
+  POST_AND_COMMENT = 'post_and_comment',
+  USER = 'user',
+}
+
+const getCommunityUserTopic = (
+  path: Amity.Subscribable['path'],
+  level?: SubscriptionLevels,
+): string => {
+  switch (level) {
+    case 'post':
+      return `${path}/post/+`;
+    case 'comment':
+      return `${path}/post/+/comment/+`;
+    case 'post_and_comment':
+      return `${path}/post/#`;
+    default:
+      return path;
+  }
+};
+
+const getNetworkId = (user: { path: string }): string => user.path.split('/user/')[0];
+
+export const getCommunityTopic = (
+  { path }: Amity.Subscribable,
+  level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
+): string => getCommunityUserTopic(path, level);
+
+export const getUserTopic = (
+  { path }: Amity.Subscribable,
+  level: Exclude<SubscriptionLevels, SubscriptionLevels.COMMUNITY> = SubscriptionLevels.USER,
+): string =>
+  getCommunityUserTopic(
+    level === SubscriptionLevels.USER ? path : path.replace(/^(\w*)/, '$1/social'),
+    level,
+  );
+
+export const getPostTopic = (
+  { path }: Amity.Subscribable,
+  level: SubscriptionLevels.POST | SubscriptionLevels.COMMENT = SubscriptionLevels.POST,
+): string => {
+  switch (level) {
+    case 'comment':
+      return `${path}/comment/+`;
+    default:
+      return path;
+  }
+};
+
+export const getCommentTopic = ({ path }: Amity.Subscribable): string => {
+  return path;
+};
+
+// Subscribe on comment and story update on a single story
+export const getStoryTopic = ({
+  targetId,
+  targetType,
+  storyId,
+}: Pick<Amity.Story, 'targetId' | 'targetType' | 'storyId'>): string => {
+  const user = getActiveUser();
+  return `${getNetworkId(user)}/social/${targetType}/${targetId}/story/${storyId}/#`;
+};
+
+// Subscribe on comment and story update on stories under community
+export const getCommunityStoriesTopic = ({
+  targetId,
+  targetType,
+}: Pick<Amity.Story, 'targetId' | 'targetType'>): string => {
+  const user = getActiveUser();
+  return `${getNetworkId(user)}/social/${targetType}/${targetId}/story/#`;
+};
+
+export const getMyFollowersTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/membership/${user._id}/+/+`;
+};
+
+export const getMyFollowingsTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/membership/+/${user._id}/+`;
+};
+
+export const getChannelTopic = (channel: Amity.Subscribable): string => `${channel.path}/#`;
+
+export const getSubChannelTopic = (subChannel: Amity.Subscribable): string =>
+  `${subChannel.path}/#`;
+
+export const getMessageTopic = (message: Amity.Subscribable): string => message.path;
+
+export const getMarkedMessageTopic = ({
+  channelId,
+  subChannelId,
+}: Pick<Amity.SubChannel, 'channelId' | 'subChannelId'>): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/marker/channel/${channelId}/message/${subChannelId}`;
+};
+
+export const getMarkerUserFeedTopic = () => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/marker/user/${user._id}`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to network level events like 'user is deleted from the network'
+ */
+export const getNetworkTopic = (): string => {
+  return getNetworkId(getActiveUser());
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to channel events for 'conversation', 'community' channel
+ */
+export const getSmartFeedChannelTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/smartfeed/${user._id}/channels`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to sub channel events for 'conversation', 'community' channel
+ */
+export const getSmartFeedSubChannelTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/smartfeed/${user._id}/messagefeeds`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to message events for 'conversation', 'community' channel
+ */
+export const getSmartFeedMessageTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
+};
+
+let mqttAccessToken: string;
+let mqttUserId: string;
+
+export function subscribeTopic(
+  topic: string,
+  callback?: Amity.Listener<ASCError | void>,
+): Amity.Unsubscriber {
+  const { mqtt } = getActiveClient();
+  if (!mqtt) return () => null;
+
+  modifyMqttConnection();
+
+  return mqtt.subscribe(topic, callback);
+}

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

@@ -0,0 +1,191 @@
+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);
+        }
+      });
+
+      NetworkActivitiesWatcher.getInstance().setNetworkActivities(
+        new Request(response.request.url, {
+          method: response.request.method,
+          headers: response.request.headers,
+          body: response.request.data,
+        }),
+        {
+          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,3 @@
+export * from './http';
+export * from './ws';
+export * from './mqtt';