@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/core/query/tests/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/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,180 @@
+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`;
+};
+
+export const getLiveStreamTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/videostreaming`;
+};
+
+export const getLiveReactionTopic = (post: Amity.Post) => {
+  return `${post.path}/liveReaction`;
+};
+
+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);
+    }
+  });
+});