@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-bef76fa.0

package/src/channel/observers/tests/liveChannels.test.ts

@@ -0,0 +1,219 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  pause,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelQueryResponse,
+  channelQueryResponsePage2,
+} from '~/utils/tests';
+
+import { liveChannels } from '../liveChannels';
+import { prepareChannelPayload } from '../../utils/prepareChannelPayload';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Channel[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+describe('liveChannels', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return channel collection', async () => {
+    // mock response of queryChannels and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels({}, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    const snapshot = getSnapshot();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // cause we apply prepareChannelPayload on channel raw data from server
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+
+    snapshot.data = payload.channels;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  // table for channel filters
+  const filters: [string, Amity.ChannelLiveCollection, number?][] = [
+    ['deleted', { isDeleted: false }],
+    ['tagged', { tags: ['tag2'] }],
+    ['out excluded tags', { excludeTags: ['tag1'] }],
+    ['member', { membership: 'member' }],
+    ['not member', { membership: 'notMember' }, 1],
+    ['all membership', { membership: 'all' }],
+  ];
+
+  test.each(filters)(
+    'it should filter by %s channels',
+    async (filter, params, expectedChannelIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+      const payload = prepareChannelPayload(channelQueryResponse.data);
+      let snapshotData = [payload.channels[expectedChannelIdx]];
+
+      // add channel users to cache for testing membership filter
+      if (params.membership) {
+        pushToCache(
+          [
+            'channelUsers',
+            'get',
+            getResolver('channelUsers')({
+              channelId: channelQueryResponse.data.channels[0].channelId,
+              userId: channelUser1.userId,
+            }),
+          ],
+          channelUser1,
+        );
+
+        if (params.membership === 'all') {
+          snapshotData = payload.channels;
+        }
+      }
+
+      liveChannels(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      const snapshot = getSnapshot();
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      snapshot.loading = false;
+      snapshot.data = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(channelQueryResponse)
+      .mockResolvedValueOnce(channelQueryResponsePage2);
+
+    liveChannels({}, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await pause();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await pause();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+    const payload2 = prepareChannelPayload(channelQueryResponsePage2.data);
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2.channels, ...payload.channels];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events, Amity.Channel][] = [
+    [
+      'it should add new channel to collection onCreate',
+      'v3.channel.didCreate',
+      { ...channel11, channelId: 'new-channel-id' },
+    ],
+    ['it should edit channel in collection onUpdate', 'v3.channel.didUpdate', channel11],
+    ['it should remove channel from collection onDelete', 'v3.channel.didDelete', channel11],
+    [
+      'it should update channel `unreadCount` onChannelMemberRead',
+      'v3.channel.didMarkSeen',
+      { ...channel11, unreadCount: channel11.unreadCount + 1 },
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, channel) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels({}, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, {
+      channels: [channel],
+      channelUsers: [channelUser1],
+      users: [],
+      files: [],
+    });
+
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+    const deletePayload = payload.channels.filter(
+      channel => channel.channelId !== channel11.channelId,
+    );
+
+    snapshot.loading = false;
+    // get data based on event
+    switch (event) {
+      case 'v3.channel.didCreate':
+        snapshot.data = [channel, ...payload.channels];
+        break;
+
+      case 'v3.channel.didUpdate':
+        snapshot.data = payload.channels;
+        break;
+
+      case 'v3.channel.didMarkSeen':
+        snapshot.data = payload.channels;
+        break;
+
+      default:
+        snapshot.data = deletePayload;
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

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/channel/utils/tests/prepareChannelPayload.test.ts

@@ -0,0 +1,120 @@
+import {
+  connectClient,
+  disconnectClient,
+  channel11,
+  channel12,
+  channelRaw1,
+  channelRaw2,
+  channelUser1,
+  channelUser2,
+} from '~/utils/tests';
+
+import { prepareChannelPayload } from '../prepareChannelPayload';
+
+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/client/api/activeClient.ts

@@ -1,6 +1,6 @@
-import { ASCError } from '~/core/errors'
+import { ASCError } from '~/core/errors';
 
-let activeClient: Amity.Client | null = null
+let activeClient: Amity.Client | null = null;
 
 /**
  * Get the active client
@@ -15,11 +15,11 @@ export const getActiveClient = () => {
       'There is no active client',
       Amity.ClientError.UNKNOWN_ERROR,
       Amity.ErrorLevel.FATAL,
-    )
+    );
   }
 
-  return activeClient!
-}
+  return activeClient!;
+};
 
 /**
  * Sets the active client
@@ -29,5 +29,5 @@ export const getActiveClient = () => {
  * @hidden
  */
 export const setActiveClient = (client: Amity.Client) => {
-  activeClient = client
-}
+  activeClient = client;
+};

package/src/client/api/activeUser.ts

@@ -0,0 +1,26 @@
+import { ASCError } from '~/core/errors';
+
+let activeUser: Pick<Amity.User, '_id' | 'userId' | 'path'> | null = null;
+
+/**
+ * for internal use
+ */
+export const getActiveUser = () => {
+  if (!activeUser) {
+    throw new ASCError(
+      'Connect client first',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.FATAL,
+    );
+  }
+
+  return activeUser!;
+};
+
+export const setActiveUser = (user: Amity.User) => {
+  activeUser = {
+    _id: user._id,
+    userId: user.userId,
+    path: user.path,
+  };
+};

package/src/client/api/connectClient.ts

@@ -1,10 +1,16 @@
-import { getDeviceId } from '~/core/device'
-import { proxyMqttEvents, proxyWebsocketEvents } from '~/core/events'
+/* eslint-disable no-param-reassign */
+/* eslint-disable require-atomic-updates */
+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 { getActiveClient } from './activeClient';
+import { setActiveUser } from './activeUser';
 
-import { getToken } from './getToken'
-import { onClientBanned } from '../events'
+import { getToken } from './getToken';
+import { onClientBanned } from '../events';
 
 /**
  * ```js
@@ -16,58 +22,63 @@ import { onClientBanned } from '../events'
  *
  * Connects an {@link Amity.Client} instance to ASC servers
  *
- * @param userId the user ID for the current session
- * @param displayName the user's displayName for the current session
- * @param deviceId Manual override of the user's device id (for device management)
- * @param authToken The authentication token - necessary when network option is set to secure
+ * @param params the connect parameters
+ * @param params.userId the user ID for the current session
+ * @param params.displayName the user's displayName for the current session
+ * @param params.deviceId Manual override of the user's device id (for device management)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
  * @returns a success boolean if connected
  *
  * @category Client API
  * @async
  */
-export const connectClient = async (params: {
-  userId: Amity.User['userId'],
-  displayName?: Amity.User['displayName'],
-  authToken?: string,
-  deviceId?: Amity.Device['deviceId'],
-}): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('client/api/connectClient', {apiKey: client.apiKey, ...params})
+export const connectClient = async (
+  params: Amity.ConnectClientParams,
+  config?: Amity.ConnectClientConfig,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });
 
   // default values
-  params.displayName ??= params.userId
-  params.deviceId ??= getDeviceId()
+  params.deviceId ??= getDeviceId();
 
   // @ts-ignore: in that particular case, typing can be
   // ignored since we enforce default values just before.
-  const { accessToken } = await getToken(params)
+  const { accessToken, users } = await getToken(params);
 
   // manually setup the token for http transport
-  client.http.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
 
   // manually setup the token for ws transport
-  client.ws.io.opts.query = {token: accessToken}
+  client.ws.io.opts.query = { token: accessToken };
 
+  // FIXME: events are duplicated if connectClient is called few times without disconnectClient
   // wire websocket events to our event emitter
-  proxyWebsocketEvents(client.ws, client.emitter)
+  proxyWebsocketEvents(client.ws, client.emitter);
 
-  // TODO connect on demand
-  await client.mqtt.connect({ accessToken, userId: params.userId })
-  proxyMqttEvents(client.mqtt, client.emitter)
-
-  // TODO: in phase 2, this should not be necessary. we should have WS, MQTT
+  // TODO: in phase 2, this should not be necessary. we should have WS
   // to be connected "on demand" rather than "by default"
   await new Promise(resolve => {
-    client.ws.once('connect', resolve)
-    client.ws.open()
-  })
+    client.ws.once('connect', resolve);
+    client.ws.open();
+  });
+
+  client.userId = params.userId;
+  client.accessToken = accessToken;
+
+  setActiveUser(users[0]);
 
-  const unsubscribe = onClientBanned(() => {
-    client.mqtt.disconnect()
-    unsubscribe()
-  })
+  if (config?.disableRTE !== true) {
+    subscribeTopic(getNetworkTopic());
+  }
 
-  client.userId = params.userId
+  const subscriptions = [
+    onClientBanned(() => {
+      disconnectClient();
+      subscriptions.forEach(fn => fn());
+    }),
+    onUserDeleted(() => null),
+  ];
 
-  return client.ws.connected
-}
+  return client.ws.connected;
+};

package/src/client/api/createClient.ts

@@ -1,13 +1,20 @@
-import { VERSION } from '~/version'
+import { VERSION } from '~/version';
 
-import { createLogger } from '~/core/debug'
+import { createLogger } from '~/core/debug';
 
-import { API_ENDPOINT, getUrlFromTemplate, UrlTemplate } from '~/core/network'
-import { createHttpTransport, createMqttTransport, createWebsocketTransport } from '~/core/transports'
+import { API_REGIONS, computeUrl } from '~/client/utils/endpoints';
+import {
+  createHttpTransport,
+  createMqttTransport,
+  createWebsocketTransport,
+} from '~/core/transports';
 
-import { createEventEmitter } from '~/core/events'
+import { createEventEmitter } from '~/core/events';
 
-import { getActiveClient, setActiveClient } from './activeClient'
+import { getActiveClient, setActiveClient } from './activeClient';
+import { getFeedSettings } from './getFeedSettings';
+
+const DEFAULT_DEBUG_SESSION = 'amity';
 
 /**
  * ```js
@@ -18,29 +25,39 @@ import { getActiveClient, setActiveClient } from './activeClient'
  * Creates a new {@link Amity.Client} instance
  *
  * @param apiKey for the {@link Amity.Client} instance
- * @param apiEndpoint endpoint to connect to
+ * @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
  *
  * @category Client API
- **/
+ * */
 export const createClient = (
   apiKey: string,
-  apiEndpoint: typeof API_ENDPOINT[keyof typeof API_ENDPOINT]|string = API_ENDPOINT.SG,
-  debugSession: string = 'amity'
+  apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS] = API_REGIONS.SG,
+  {
+    debugSession = DEFAULT_DEBUG_SESSION,
+    apiEndpoint,
+  }: {
+    debugSession?: string;
+    apiEndpoint?: { http?: string; mqtt?: string };
+  } = {},
 ): Amity.Client => {
-  const log = createLogger(debugSession)
+  const log = createLogger(debugSession);
 
   log('client/api/createClient', {
     apiKey: apiKey.replace(/.{5}$/g, 'xxxxx'),
-    apiEndpoint,
-  })
+    apiRegion,
+  });
 
-  const http = createHttpTransport(getUrlFromTemplate(UrlTemplate.HTTP, apiEndpoint))
-  const ws = createWebsocketTransport(getUrlFromTemplate(UrlTemplate.HTTP, apiEndpoint))
-  const mqtt = createMqttTransport(getUrlFromTemplate(UrlTemplate.MQTT, apiEndpoint));
+  const httpEndpoint = apiEndpoint?.http ?? computeUrl('http', apiRegion);
+  const mqttEndpoint = apiEndpoint?.mqtt ?? computeUrl('mqtt', apiRegion);
 
-  const emitter = createEventEmitter()
+  const http = createHttpTransport(httpEndpoint);
+  const ws = createWebsocketTransport(httpEndpoint);
+  const mqtt = createMqttTransport(mqttEndpoint);
+
+  const emitter = createEventEmitter();
 
   const client = {
     version: `${VERSION}`,
@@ -52,13 +69,15 @@ export const createClient = (
     mqtt,
     emitter,
     use: () => setActiveClient(client),
-  }
+
+    getFeedSettings,
+  };
 
   try {
-    getActiveClient()
+    getActiveClient();
   } catch {
-    setActiveClient(client)
+    setActiveClient(client);
   }
 
-  return client
-}
+  return client;
+};

package/src/client/api/disconnectClient.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from './activeClient'
+import { getActiveClient } from './activeClient';
 
 /**
  * ```js
@@ -15,19 +15,21 @@ import { getActiveClient } from './activeClient'
  * @async
  */
 export const disconnectClient = async (): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('client/api/disconnectClient')
+  const client = getActiveClient();
+  client.log('client/api/disconnectClient');
 
   await new Promise(resolve => {
-    client.ws.once('disconnect', resolve)
-    client.ws.disconnect()
-    client.mqtt.disconnect()
-  })
+    client.ws.once('disconnect', resolve);
+    client.ws.disconnect();
+    client.mqtt.disconnect();
+  });
 
-  client.emitter.all.clear()
-  client.ws.removeAllListeners()
-  client.mqtt.removeAllListeners()
-  client.userId = undefined
+  client.emitter.all.clear();
+  // FIXME: it removes listener in ws.ts, it breaks global ban event
+  client.ws.removeAllListeners();
+  client.mqtt.removeAllListeners();
+  client.userId = undefined;
+  client.accessToken = undefined;
 
-  return !client.ws.connected
-}
+  return !client.ws.connected;
+};