@amityco/ts-sdk 0.0.1-003998f.0

package/src/core/query/sorting.ts

@@ -0,0 +1,56 @@
+// Note:
+// this file should contain a suite of sorting utilities to help the
+// local version of the query functions.
+
+type SortingFunc<T = Record<string, unknown>> = (a: T, b: T) => number;
+
+/**
+ * Alphabetic sorting of objects having a displayName
+ */
+export const sortByDisplayName: SortingFunc<{ displayName: string }> = (
+  { displayName: a },
+  { displayName: b },
+) => {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+};
+
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+export const sortByChannelSegment: SortingFunc<{ channelSegment: number }> = (
+  { channelSegment: a },
+  { channelSegment: b },
+) => a - b;
+
+/**
+ * Sorting a collection by their apparition order (oldest first)
+ */
+export const sortBySegmentNumber: SortingFunc<{ segmentNumber: number }> = (
+  { segmentNumber: a },
+  { segmentNumber: b },
+) => a - b;
+
+/**
+ * Sorting a collection by its oldest items
+ */
+export const sortByFirstCreated: SortingFunc<{ createdAt: Date | number | string }> = (
+  { createdAt: a },
+  { createdAt: b },
+) => new Date(a).valueOf() - new Date(b).valueOf();
+
+/**
+ * Sorting a collection by its newest items
+ */
+export const sortByLastCreated: SortingFunc<{ createdAt: Date | number | string }> = (
+  { createdAt: a },
+  { createdAt: b },
+) => new Date(b).valueOf() - new Date(a).valueOf();
+
+/**
+ * Sorting a collection by the items with most recent activity
+ */
+export const sortByLastActivity: SortingFunc<{ lastActivity: Date | number | string }> = (
+  { lastActivity: a },
+  { lastActivity: b },
+) => new Date(b).valueOf() - new Date(a).valueOf();

package/src/core/subscription.ts

@@ -0,0 +1,128 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { ASCError } from '~/core/errors';
+import { proxyMqttEvents } from '~/core/events';
+import { getActiveUser } from '~/client/api/activeUser';
+
+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;
+};
+
+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 getMessageTopic = (message: Amity.Subscribable): string => message.path;
+
+/**
+ * @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 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, emitter, accessToken } = getActiveClient();
+  const user = getActiveUser();
+
+  if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
+    mqttAccessToken = accessToken!;
+    mqttUserId = user._id!;
+
+    mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
+    proxyMqttEvents(mqtt, emitter);
+  }
+
+  return mqtt.subscribe(topic, callback);
+}

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

@@ -0,0 +1,11 @@
+import { filterByPropEquality } from '~/core/query';
+
+describe('Core/Query/Filtering', () => {
+  test('check filterByPropEquality', () => {
+    const prop = 'prop';
+    const collection = [{ [prop]: 'value' }];
+
+    expect(filterByPropEquality(collection, prop, 'value')).toStrictEqual(collection);
+    expect(filterByPropEquality(collection, prop, 'otherValue')).toStrictEqual([]);
+  });
+});

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

@@ -0,0 +1,15 @@
+import { getChannelTopic, getMessageTopic } from '../subscription';
+
+describe('Subscription', () => {
+  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');
+  });
+});

package/src/core/transports/http.ts

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import qs from 'qs';
+import HttpAgent, { HttpsAgent } from 'agentkeepalive';
+
+import { unwrapPayload } from './utils';
+
+/**
+ * Axios param serializer (for querystring)
+ * @hidden
+ */
+export const stringify = (params: Record<string, unknown>): string => {
+  return qs.stringify(params, { arrayFormat: 'brackets' });
+};
+
+/**
+ * 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),
+    paramsSerializer: stringify,
+  });
+
+  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);
+    },
+  );
+
+  return instance;
+};

package/src/core/transports/index.ts

@@ -0,0 +1,3 @@
+export * from './http';
+export * from './ws';
+export * from './mqtt';