@amityco/ts-sdk 0.0.1-beta.27 → 0.0.1-beta.28

package/src/channel/tests/utils/prepareChannelPayload.test.ts

@@ -0,0 +1,120 @@
+import {
+  connectClient,
+  disconnectClient,
+  channel11,
+  channel12,
+  channelRaw1,
+  channelRaw2,
+  channelUser1,
+  channelUser2,
+} from '~/utils/tests';
+
+import { prepareChannelPayload } from '../../utils';
+
+beforeAll(async () => {
+  await connectClient();
+});
+
+afterAll(async () => {
+  await disconnectClient();
+});
+
+const responseSchema = {
+  channels: [],
+  channelUsers: [],
+  files: [],
+  users: [],
+};
+
+const tests = [
+  {
+    id: 1,
+    desc: 'hasMention: false, unreadCount: 0, if channelUsers is empty',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+    },
+  },
+  {
+    id: 2,
+    desc: 'hasMention: false, if channelUser.readToSegment >= channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 3,
+    desc: 'unreadCount: 0, if channelUser.readToSegment = channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, if channelUser.readToSegment < channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 5,
+    desc: 'unreadCount: > 0, if channelUser.readToSegment < channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, unreadCount: > 0, if 4 / 5 ',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+];
+
+describe('channel/utils/prepareChannelPayload', () => {
+  tests.forEach(({ id, desc, before, after }) => {
+    test(`${id} - ${desc}`, () => {
+      expect(prepareChannelPayload(before)).toEqual(after);
+    });
+  });
+});

package/src/channel/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareChannelPayload';

package/src/channel/utils/prepareChannelPayload.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+export const prepareChannelPayload = (
+  payload: Amity.ChannelPayload,
+): Amity.ChannelPayload<any, Amity.Channel> => {
+  const client = getActiveClient();
+
+  const channels: Amity.Channel[] = payload.channels.map(channel => {
+    const channelUser = payload.channelUsers.find(
+      channelUser =>
+        channelUser.userId === client.userId && channel.channelId === channelUser.channelId,
+    )!;
+
+    const hasMention = channelUser
+      ? channelUser.readToSegment < channelUser.lastMentionedSegment
+      : false;
+    const unreadCount =
+      channelUser && channelUser.membership === 'member' && channel.messageCount
+        ? Math.max(0, channel.messageCount - channelUser.readToSegment)
+        : 0;
+
+    return {
+      ...channel,
+      hasMention,
+      unreadCount,
+    };
+  });
+
+  return { ...payload, channels };
+};

package/src/client/api/connectClient.ts

@@ -3,14 +3,14 @@
 import { disconnectClient } from '~/client/api/disconnectClient';
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
+import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
+import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 import { getActiveClient } from './activeClient';
 import { setActiveUser } from './activeUser';
 
 import { getToken } from './getToken';
 import { onClientBanned } from '../events';
-import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
-import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 /**
  * ```js
@@ -33,13 +33,8 @@ import { onUserDeleted } from '~/user/events/onUserDeleted';
  * @async
  */
 export const connectClient = async (
-  params: {
-    userId: Amity.User['userId'];
-    displayName?: Amity.User['displayName'];
-    authToken?: string;
-    deviceId?: Amity.Device['deviceId'];
-  },
-  config?: { disableRTE: boolean },
+  params: Amity.ConnectClientParams,
+  config?: Amity.ConnectClientConfig,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });

package/src/client/api/createClient.ts

@@ -12,6 +12,9 @@ import {
 import { createEventEmitter } from '~/core/events';
 
 import { getActiveClient, setActiveClient } from './activeClient';
+import { getFeedSettings } from './getFeedSettings';
+
+const DEFAULT_DEBUG_SESSION = 'amity';
 
 /**
  * ```js
@@ -23,6 +26,7 @@ import { getActiveClient, setActiveClient } from './activeClient';
  *
  * @param apiKey for the {@link Amity.Client} instance
  * @param apiRegion endpoint to connect to
+ * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
  * @param debugSession session's identifier for the client's logger instance
  * @returns A {@link Amity.Client} instance
  *
@@ -31,7 +35,13 @@ import { getActiveClient, setActiveClient } from './activeClient';
 export const createClient = (
   apiKey: string,
   apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS] = API_REGIONS.SG,
-  debugSession = 'amity',
+  {
+    debugSession = DEFAULT_DEBUG_SESSION,
+    apiEndpoint,
+  }: {
+    debugSession?: string;
+    apiEndpoint?: { http?: string; mqtt?: string };
+  } = {},
 ): Amity.Client => {
   const log = createLogger(debugSession);
 
@@ -40,9 +50,12 @@ export const createClient = (
     apiRegion,
   });
 
-  const http = createHttpTransport(computeUrl('http', apiRegion));
-  const ws = createWebsocketTransport(computeUrl('http', apiRegion));
-  const mqtt = createMqttTransport(computeUrl('mqtt', apiRegion));
+  const httpEndpoint = apiEndpoint?.http ?? computeUrl('http', apiRegion);
+  const mqttEndpoint = apiEndpoint?.mqtt ?? computeUrl('mqtt', apiRegion);
+
+  const http = createHttpTransport(httpEndpoint);
+  const ws = createWebsocketTransport(httpEndpoint);
+  const mqtt = createMqttTransport(mqttEndpoint);
 
   const emitter = createEventEmitter();
 
@@ -56,6 +69,8 @@ export const createClient = (
     mqtt,
     emitter,
     use: () => setActiveClient(client),
+
+    getFeedSettings,
   };
 
   try {

package/src/client/api/getFeedSettings.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { getFeedSettings } from '@amityco/ts-sdk'
+ * const feedSettings = await getFeedSettings()
+ * const postFeedSetting = feedSettings.post
+ * ```
+ *
+ * Fetches a {@link Amity.FeedSettings} object
+ *
+ * @returns A Promise of {@link Amity.FeedSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+export const getFeedSettings = async (): Promise<Amity.FeedSettings> => {
+  const client = getActiveClient();
+
+  const { data } = await client.http.get<Amity.FeedSettingPayload>(
+    `/api/v3/network-settings/feed-setting`,
+  );
+
+  return Object.fromEntries(
+    data.feedSettings.map(({ feedType, contentSettings }) => {
+      return [feedType, contentSettings];
+    }),
+  );
+};

package/src/client/api/index.ts

@@ -6,3 +6,5 @@ export * from './connectClient';
 export * from './disconnectClient';
 
 export * from './isConnected';
+
+export * from './getFeedSettings';

package/src/core/events.ts

@@ -13,8 +13,9 @@ const WS_EVENTS = [
   'reconnect_error',
   'reconnect_failed',
 
+  'v3.channel.didCreate',
   'v3.channel.didUpdate',
-  'v3.channel.didUpdate',
+  'v3.channel.didDelete',
   'v3.channel.didJoin',
   'v3.channel.didLeave',
   'v3.channel.didAddUsers',

package/src/core/query/query.ts

@@ -85,7 +85,7 @@ export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
  * This wrapper is necessary to create for optimistically calls
  *
  *
- * @param fn A compatible API function from the ts sdk
+ * @param func A compatible API function from the ts sdk
  * @param args The arguments to pass to the function passed as `fn`
  * @returns A wrapper containing both the function and its future arguments
  *
@@ -221,8 +221,8 @@ export const runQuery = <Args extends any[], Returned extends any>(
        * the modal key in the param itself
        * For update & delete the first argument is always an id which is of type
        * string, whereas for create the first and only argument is the param object
-       * 
-       * When creating an AmityObject optimistically we need to pass the modal key 
+       *
+       * When creating an AmityObject optimistically we need to pass the modal key
        * on to the server. ex: for create message modal key will be 'messageId`
        */
       if (typeof args[0] !== 'string') {

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/file/api/createVideo.ts

@@ -11,6 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
@@ -19,6 +20,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const createVideo = async (
   formData: FormData,
+  feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
@@ -27,6 +29,10 @@ export const createVideo = async (
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
 
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
   const headers =
     'getHeaders' in formData
       ? (formData as any).getHeaders()

package/src/follow/api/queryFollowers.ts

@@ -14,11 +14,9 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowers = async (query: {
-  userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatusType, 'none'>;
-  page?: Amity.PageRaw;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+export const queryFollowers = async (
+  query: Amity.QueryFollowers,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
   queryFollows('followers', query);
 
 /**

package/src/follow/api/queryFollowings.ts

@@ -14,11 +14,9 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowings = async (query: {
-  userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatusType, 'none'>;
-  page?: Amity.PageRaw;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+export const queryFollowings = async (
+  query: Amity.QueryFollowings,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
   queryFollows('following', query);
 
 /**

package/src/follow/api/utils.ts

@@ -36,9 +36,9 @@ export const queryFollows = async (
     ingestInCache(payload as Amity.FollowersPayload, { cachedAt });
 
     const cacheKey = [
-      key,
+      'follow',
       'query',
-      { ...params, userId, options: { ...page } } as Amity.Serializable,
+      { ...params, userId, options: { ...page }, type: key } as Amity.Serializable,
     ];
     pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
   }
@@ -60,7 +60,11 @@ queryFollows.locally = (
 
   const { page, ...params } = query;
 
-  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = [
+    'follow',
+    'query',
+    { ...params, options: { ...page }, type: key } as Amity.Serializable,
+  ];
   const { data, cachedAt } =
     pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {};
 

package/src/follow/observers/index.ts

@@ -1,3 +1,6 @@
 export * from './observeFollowInfo';
 export * from './observeFollowers';
 export * from './observeFollowings';
+
+export * from './liveFollowers';
+export * from './liveFollowings';