@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,111 +0,0 @@
-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

@@ -1,180 +0,0 @@
-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

@@ -1,180 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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);
-    }
-  });
-});