@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/src/channel/utils/index.ts

@@ -0,0 +1,57 @@
+import { pullFromCache } from '~/cache/api';
+import { withUsers } from '~/group/utils';
+
+export function convertFromRaw(
+  { _id, ...rest }: Amity.RawChannel,
+  params: Pick<
+    Amity.Channel,
+    | 'defaultSubChannelHasUnreadMention'
+    | 'defaultSubChannelUnreadCount'
+    | 'localLastMentionSegment'
+    | 'localReadToSegment'
+  >,
+): Amity.Channel {
+  return {
+    ...rest,
+    ...params,
+    defaultSubChannelId: _id,
+  };
+}
+
+function getSegmentParams(rawChannel: Amity.RawChannel) {
+  let cached;
+
+  try {
+    cached = pullFromCache<Amity.Channel>(['channel', 'get', rawChannel.channelId]);
+    // eslint-disable-next-line no-empty
+  } catch {}
+
+  if (cached) {
+    return {
+      defaultSubChannelHasUnreadMention: cached.data.defaultSubChannelHasUnreadMention,
+      defaultSubChannelUnreadCount: cached.data.defaultSubChannelUnreadCount,
+      localReadToSegment: cached.data.localReadToSegment,
+      localLastMentionSegment: cached.data.localLastMentionSegment,
+    };
+  }
+
+  return {
+    defaultSubChannelHasUnreadMention: false,
+    defaultSubChannelUnreadCount: 0,
+    // @ts-ignore
+    localReadToSegment: rawChannel.messageCount > 0 ? rawChannel.messageCount - 1 : 0,
+    localLastMentionSegment: 0,
+  };
+}
+
+export const prepareChannelPayload = (
+  rawPayload: Amity.ChannelPayload,
+): Amity.ProcessedChannelPayload => {
+  const channels: Amity.Channel[] = rawPayload.channels.map(channel =>
+    convertFromRaw(channel, getSegmentParams(channel)),
+  );
+
+  const channelUsers: Amity.Membership<'channel'>[] = withUsers(rawPayload.channelUsers);
+
+  return { ...rawPayload, channels, channelUsers };
+};

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

@@ -0,0 +1,120 @@
+import {
+  connectClient,
+  disconnectClient,
+  channel1,
+  channel2,
+  channelRaw1,
+  channelRaw2,
+  rawChannelUser,
+  rawChannelUser2,
+} from '~/utils/tests';
+
+import { prepareChannelPayload } from '..';
+
+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: [channel1],
+    },
+  },
+  {
+    id: 2,
+    desc: 'hasMention: false, if channelUser.readToSegment >= channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [rawChannelUser],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel1],
+      channelUsers: [rawChannelUser],
+    },
+  },
+  {
+    id: 3,
+    desc: 'unreadCount: 0, if channelUser.readToSegment = channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [rawChannelUser],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel1],
+      channelUsers: [rawChannelUser],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, if channelUser.readToSegment < channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [rawChannelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel2],
+      channelUsers: [rawChannelUser2],
+    },
+  },
+  {
+    id: 5,
+    desc: 'unreadCount: > 0, if channelUser.readToSegment < channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [rawChannelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel2],
+      channelUsers: [rawChannelUser2],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, unreadCount: > 0, if 4 / 5 ',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [rawChannelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel2],
+      channelUsers: [rawChannelUser2],
+    },
+  },
+];
+
+xdescribe('channel/utils/prepareChannelPayload', () => {
+  tests.forEach(({ id, desc, before, after }) => {
+    test(`${id} - ${desc}`, () => {
+      expect(prepareChannelPayload(before)).toEqual(after);
+    });
+  });
+});

package/src/client/api/accessTokenExpiryWatcher.ts

@@ -0,0 +1,85 @@
+import { fireEvent } from '~/core/events';
+import { scheduleTask } from '~/core/microtasks';
+import { MINUTE, ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
+
+import { renewal } from './renewal';
+
+const ABOUT_TO_EXPIRE_THRESHOLD = 80 / 100;
+const COMPENSATED_DELAY = 5 * MINUTE;
+
+/*
+ * a helper function to check if the token has expires
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token expires
+ *
+ * @category private
+ */
+export const isExpired = (expiresAt: Amity.Tokens['expiresAt']): boolean =>
+  Date.now() > Date.parse(expiresAt) - COMPENSATED_DELAY;
+
+/*
+ * a helper function to check if the token is about to expire
+ *
+ * @param token to be checked
+ * @returns boolean indicating if token is aboutToExpire
+ *
+ * @category private
+ */
+export const isAboutToExpire = (params: {
+  expiresAt: Amity.Tokens['expiresAt'];
+  issuedAt: Amity.Tokens['issuedAt'];
+}): boolean => {
+  const { expiresAt, issuedAt } = params;
+
+  const expires = Date.parse(expiresAt);
+  const issued = Date.parse(issuedAt);
+  const now = Date.now();
+
+  const duration = expires - issued - COMPENSATED_DELAY;
+  const aboutToExpireAt = issued + duration * ABOUT_TO_EXPIRE_THRESHOLD;
+
+  return now > aboutToExpireAt && now < expires;
+};
+
+/*
+ * Monitors time to expire of token and updates session state to aboutToExpire
+ *
+ * @returns intervalId to be cleared after trigger
+ *
+ * @category private
+ */
+export const accessTokenExpiryWatcher = (
+  expiresAt: Amity.Tokens['expiresAt'],
+  issuedAt: Amity.Tokens['issuedAt'],
+  sessionHandler: Amity.SessionHandler,
+): Amity.Unsubscriber => {
+  const interval: ReturnType<typeof setInterval> = setInterval(() => {
+    if (isExpired(expiresAt)) {
+      /*
+       * the event handler will take care of updating session state
+       * Note, this will also clear the interval id, so this event will only be
+       * fired once
+       */
+      fireEvent('tokenExpired', Amity.SessionStates.TOKEN_EXPIRED);
+
+      /*
+       * https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2082537485/ASC+Core+-+Session+Management+3.0#Automatically-initiate-renewal-flow
+       *
+       * Why sechduled task?
+       * Since fireEvent is scheduled, it will be called
+       * after sessionHandler leading to an invalid state change from
+       * establishing to tokenExpired
+       */
+      scheduleTask(() => sessionHandler.sessionWillRenewAccessToken(renewal()));
+
+      return;
+    }
+
+    if (isAboutToExpire({ expiresAt, issuedAt })) {
+      sessionHandler.sessionWillRenewAccessToken(renewal());
+    }
+  }, ACCESS_TOKEN_WATCHER_INTERVAL);
+
+  return (): void => clearInterval(interval);
+};

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' | 'displayName'> | 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,41 @@
-import { getDeviceId } from '~/core/device'
-import { 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 {
+  getUserTopic,
+  getNetworkTopic,
+  getSmartFeedChannelTopic,
+  getSmartFeedMessageTopic,
+  getSmartFeedSubChannelTopic,
+  subscribeTopic,
+} from '~/core/subscription';
 
-import { getActiveClient } from './activeClient'
+import { onUserDeleted } from '~/user/events/onUserDeleted';
 
-import { getToken } from './getToken'
+import { getActiveClient } from './activeClient';
+import { terminateClient } from './terminateClient';
+import { setActiveUser, getActiveUser } from './activeUser';
 
+import { setSessionState } from './setSessionState';
+
+import { onClientBanned } from '../events';
+import { onTokenExpired } from '../events/onTokenExpired';
+import { onTokenTerminated } from '../events/onTokenTerminated';
+
+import { setClientToken } from '../utils/setClientToken';
+
+/*
+ * declared earlier to accomodate case when logging in with a different user
+ * than the one already connected, in which case the existing subscriptions need
+ * to be cleared
+ */
+const subscriptions: Amity.Unsubscriber[] = [];
+
+/* begin_public_function
+  id: client.login
+*/
 /**
  * ```js
  * import { connectClient } from '@amityco/ts-sdk/client/api'
@@ -15,49 +46,129 @@ import { getToken } from './getToken'
  *
  * 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,
+  sessionHandler: Amity.SessionHandler,
+  config?: Amity.ConnectClientConfig,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  let unsubWatcher: Amity.Unsubscriber;
+
+  client.log('client/api/connectClient', {
+    apiKey: client.apiKey,
+    sessionState: client.sessionState,
+    ...params,
+  });
+
+  // if connecting to a different userId than the one that is connected currently
+  if (client.userId && client.userId !== params.userId) {
+    await disconnectClient();
+
+    // Remove subscription to ban and delete
+    subscriptions.forEach(fn => fn());
+  }
 
   // default values
-  params.displayName ??= params.userId
-  params.deviceId ??= getDeviceId()
+  params.deviceId ??= getDeviceId();
+
+  try {
+    // @ts-ignore: in that particular case, typing can be
+    // ignored since we enforce default values just before.
+    const { users } = await setClientToken(params);
+
+    // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+    // wire websocket events to our event emitter
+    proxyWebsocketEvents(client.ws, client.emitter);
+
+    // 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.userId = params.userId;
+
+    client.sessionHandler = sessionHandler;
+
+    /*
+     * Cannot push to subscriptions as watcher needs to continue working even if
+     * token expires
+     */
+    unsubWatcher = client.accessTokenExpiryWatcher(
+      client.token?.issuedAt!,
+      client.token?.expiresAt!,
+      sessionHandler!,
+    );
+
+    setActiveUser(users[0]);
+  } catch (error) {
+    /*
+     * if getting token failed session state reverts to initial state when app
+     * is first launched
+     */
+    setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
+
+    // pass error down tree so the calling function handle it
+    throw error;
+  }
+
+  if (config?.disableRTE !== true) {
+    subscribeTopic(getNetworkTopic());
+    subscribeTopic(getSmartFeedChannelTopic());
+    subscribeTopic(getSmartFeedSubChannelTopic());
+    subscribeTopic(getSmartFeedMessageTopic());
+    // subscribing to user topic is necessary to handle ban event
+    subscribeTopic(getUserTopic(getActiveUser()));
+  }
+
+  subscriptions.push(
+    // GLOBAL_BAN
+    onClientBanned((_: Amity.UserPayload) => {
+      terminateClient();
+
+      subscriptions.forEach(fn => fn());
+
+      unsubWatcher();
+    }),
+
+    onTokenTerminated(_ => {
+      terminateClient();
+
+      subscriptions.forEach(fn => fn());
+
+      unsubWatcher();
+    }),
 
-  // @ts-ignore: in that particular case, typing can be
-  // ignored since we enforce default values just before.
-  const { accessToken } = await getToken(params)
+    onUserDeleted((user: Amity.User) => {
+      if (user.userId === client.userId) {
+        terminateClient();
 
-  // manually setup the token for http transport
-  client.http.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`
+        subscriptions.forEach(fn => fn());
 
-  // manually setup the token for ws transport
-  client.ws.io.opts.query = {token: accessToken}
+        unsubWatcher();
+      }
+    }),
 
-  // wire websocket events to our event emitter
-  proxyWebsocketEvents(client.ws, client.emitter)
+    onTokenExpired(state => {
+      setSessionState(state);
 
-  // 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()
-  })
+      disconnectClient();
 
-  client.userId = params.userId
+      subscriptions.forEach(fn => fn());
+    }),
+  );
 
-  return client.ws.connected
-}
+  return client.ws.connected;
+};
+/* end_public_function */

package/src/client/api/createClient.ts

@@ -1,16 +1,22 @@
-import { createLogger } from '~/core/debug'
+import { VERSION } from '~/version';
 
+import { createLogger } from '~/core/debug';
+
+import { API_REGIONS, computeUrl } from '~/client/utils/endpoints';
 import {
   createHttpTransport,
+  createMqttTransport,
   createWebsocketTransport,
-} from '~/core/transports'
+} 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';
+
+import { accessTokenExpiryWatcher } from './accessTokenExpiryWatcher';
+
+const DEFAULT_DEBUG_SESSION = 'amity';
 
 /**
  * ```js
@@ -21,36 +27,65 @@ import {
  * Creates a new {@link Amity.Client} instance
  *
  * @param apiKey for the {@link Amity.Client} instance
- * @param apiEndpoint endpoint to connect to
- * @param debugSession session's identifier for the client's logger instance
+ * @param apiRegion endpoint to connect to
+ * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
+ * @param 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: string = 'https://api.amity.co',
-  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(apiEndpoint)
-  const ws = createWebsocketTransport(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 sessionState = Amity.SessionStates.NOT_LOGGED_IN;
+  const sessionHandler = undefined;
 
   const client = {
-    apiKey, log, http, ws, emitter,
+    version: `${VERSION}`,
+
+    apiKey,
+    log,
+    http,
+    ws,
+    mqtt,
+    emitter,
+    accessTokenExpiryWatcher,
     use: () => setActiveClient(client),
-  }
 
-  try { getActiveClient() }
-  catch { setActiveClient(client) }
+    sessionState,
+    sessionHandler,
+    getFeedSettings,
+  };
+
+  try {
+    return getActiveClient();
+  } catch {
+    setActiveClient(client);
+  }
 
-  return client
-}
+  return client;
+};