@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/client/utils/localStorage.ts

@@ -0,0 +1,53 @@
+class OnMemoryStorage {
+  private store: { [key: string]: string } = {};
+
+  constructor() {
+    this.store = {};
+  }
+
+  clear() {
+    this.store = {};
+  }
+
+  getItem(key: string) {
+    return this.store[key] || null;
+  }
+
+  setItem(key: string, value: string) {
+    this.store[key] = String(value);
+  }
+
+  removeItem(key: string) {
+    delete this.store[key];
+  }
+
+  get length() {
+    return Object.keys(this.store).length;
+  }
+
+  key(i: number): string | null {
+    const keys = Object.keys(this.store);
+    // @ts-ignore
+    return keys[i] || null;
+  }
+}
+
+const windowInstance = () => {
+  if (typeof window !== 'undefined' && window.localStorage) return window;
+  // For JEST
+  return { localStorage: new OnMemoryStorage() };
+};
+
+export const setItem = async (key: string, value: string): Promise<boolean> => {
+  return new Promise(resolve => {
+    windowInstance().localStorage.setItem(key, value);
+    resolve(true);
+  });
+};
+
+export const getItem = async (key: string): Promise<string | null | undefined> => {
+  return new Promise(resolve => {
+    const value = windowInstance().localStorage.getItem(key);
+    resolve(value);
+  });
+};

package/src/client/utils/markerSyncEngine.ts

@@ -0,0 +1,217 @@
+import {
+  onChannelCreated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+} from '~/channelRepository/events';
+import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync';
+import { setIntervalTask } from '~/utils/timer';
+import { getUserMarker } from '~/marker/api/getUserMarker';
+import { onFeedMarkerUpdated } from '~/marker/events/onFeedlMarkerUpdated';
+import { onMessageCreatedMqtt } from '~/messageRepository/events/onMessageCreated';
+import { onSubChannelCreated } from '~/subChannelRepository/events/onSubChannelCreated';
+import { onSubChannelDeleted } from '~/subChannelRepository/events/onSubChannelDeleted';
+import { isUnreadCountSupport } from '~/subChannelRepository/utils';
+
+import { markerSync } from '../api/markerSync';
+
+import { onOnline } from './onOnline';
+import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { getActiveClient } from '~/client/api/activeClient';
+
+const SYNC_TRIGGER_INTERVAL_TIME = 2000;
+const ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY = 2000;
+
+let isSyncRunning = false;
+let disposers: (() => void)[] = [];
+let isWaitingForResponse = false;
+
+const isConsistentMode = true;
+let deviceLastSyncAt: Date | null = null;
+
+const getDeviceLastSyncAt = () => {
+  if (deviceLastSyncAt == null) {
+    return new Date();
+  }
+
+  return deviceLastSyncAt;
+};
+
+const saveDeviceLastSyncAt = (lastSyncAt: Date | null) => {
+  if (lastSyncAt == null) return;
+  if (!deviceLastSyncAt || lastSyncAt.getTime() > deviceLastSyncAt.getTime()) {
+    deviceLastSyncAt = lastSyncAt;
+  }
+};
+
+const fetchDeviceLastSyncAt = async () => {
+  const { data: userMarker } = await getUserMarker();
+  if (userMarker == null) return;
+  saveDeviceLastSyncAt(new Date(userMarker.lastSyncAt));
+};
+
+/**
+ * list of conditions that make timer still trigger the syncing process.
+ * If it's empty, it means sync is stopped.
+ * if it's not empty, sync will resume.
+ */
+let events: Amity.MarkerSyncEvent[] = [];
+
+/**
+ * get current marker sync event list
+ * @private
+ */
+export const getMarkerSyncEvents = () => events;
+
+/**
+ * set marker sync events
+ * @private
+ */
+export const setMarkerSyncEvents = (newEvents: Amity.MarkerSyncEvent[]) => {
+  events = newEvents;
+};
+
+/**
+ * push new event to marker sync events
+ * @private
+ */
+export const pushMarkerSyncEvent = (event: Amity.MarkerSyncEvent) => events.push(event);
+
+/**
+ * interval task
+ * @private
+ */
+export const markerSyncTrigger = async () => {
+  if (isWaitingForResponse) {
+    // waiting for the response no need to make another API call
+    return;
+  }
+
+  if (events.length === 0) {
+    // no event that require to call marker sync API
+    return;
+  }
+  try {
+    isWaitingForResponse = true;
+    // any past events are considered processed here.
+    // however during waiting for the response, RTE could add the new message event;
+    // which will make the engine trigger another call next round.
+    events = [];
+
+    const response = await markerSync(getDeviceLastSyncAt().toISOString());
+
+    const latestLastSyncAt: Date | null = response.data.userMarkers.reduce(
+      (maxLastSyncAt, userMarker) => {
+        if (
+          maxLastSyncAt == null ||
+          maxLastSyncAt.getTime() < new Date(userMarker.lastSyncAt).getTime()
+        ) {
+          return new Date(userMarker.lastSyncAt);
+        }
+
+        return maxLastSyncAt;
+      },
+      null as Date | null,
+    );
+
+    saveDeviceLastSyncAt(latestLastSyncAt);
+
+    if (response.hasMore) {
+      events.push(Amity.MarkerSyncEvent.HAS_MORE);
+    }
+  } catch {
+    // prevent sync from stopping
+  } finally {
+    if (isWaitingForResponse) {
+      isWaitingForResponse = false;
+    }
+  }
+};
+
+const registerEventListeners = () => {
+  if (disposers.length > 0) {
+    return;
+  }
+  // based on the tech spec design, we designed a fetch marker in case of these events
+  // - new message
+  // - create channel
+  // - remove channel
+  // - app going to online again after offline
+  disposers.push(
+    onOnline(() => {
+      // should add RESUME to the event to trigger marker syncing again
+      events.push(Amity.MarkerSyncEvent.RESUME);
+    }),
+
+    onMessageCreatedMqtt(message => {
+      // only conversation, community and broadcast types can sync
+      const client = getActiveClient();
+      if (isUnreadCountSupport(message) && message.creatorId !== client.userId)
+        events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
+    }),
+
+    onChannelCreated(() => events.push(Amity.MarkerSyncEvent.CHANNEL_CREATED)),
+    onChannelDeleted(() => events.push(Amity.MarkerSyncEvent.CHANNEL_DELETED)),
+    onChannelJoined(() => events.push(Amity.MarkerSyncEvent.CHANNEL_JOINED)),
+    onChannelLeft(() => events.push(Amity.MarkerSyncEvent.CHANNEL_LEFT)),
+    onSubChannelCreated(() => events.push(Amity.MarkerSyncEvent.SUB_CHANNEL_CREATED)),
+    onSubChannelDeleted(() =>
+      /*
+       workaround: when receiving the event for sub-channel deletion,
+       before triggering marker update, the SDK will have to add a 2-second delay.
+       so that the unread count is calculated correctly.
+      */
+      setTimeout(
+        () => events.push(Amity.MarkerSyncEvent.SUBCHANNEL_IS_DELETED),
+        ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY,
+      ),
+    ),
+    onFeedMarkerUpdated(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
+    onUserMarkerSync(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
+    onUserFeedMarkerUpdated(() => events.push(Amity.MarkerSyncEvent.MARKER_UPDATED)),
+  );
+};
+
+const unRegisterEventListeners = () => {
+  disposers.forEach(fn => fn());
+  disposers = [];
+};
+
+export const startMarkerSync = async () => Promise.resolve();
+
+/**
+ ```js
+ * import { startUnreadSync } from '@amityco/ts-sdk'
+ * startUnreadSync()
+ * ```
+ *
+ * start syncing to keep feed markers, channel markers and user makers cache
+ * update to the server.
+ *
+ * @category Marker API
+ */
+export const startUnreadSync = async () => Promise.resolve();
+
+/**
+ ```js
+ * import { stopUnreadSync } from '@amityco/ts-sdk'
+ * stopUnreadSync()
+ * ```
+ *
+ * stop unread syncing
+ *
+ * @category Marker API
+ */
+export const stopUnreadSync = () => {
+  isSyncRunning = false;
+  setMarkerSyncEvents([]);
+  unRegisterEventListeners();
+};
+
+setIntervalTask(async () => {
+  if (!isSyncRunning) return;
+
+  await markerSyncTrigger();
+}, SYNC_TRIGGER_INTERVAL_TIME);
+
+export const getMarkerSyncConsistentMode = () => isConsistentMode;

package/src/client/utils/messagePreviewEngine.ts

@@ -0,0 +1,114 @@
+import { dropFromCache, pullFromCache, pushToCache, queryCache } from '~/cache/api';
+import { getChatSettings } from '../api/getChatSettings';
+
+import { getChannelByIds } from '~/channelRepository/api/getChannelByIds';
+import { getSubChannels as getSubChannelByIds } from '~/subChannelRepository/api/getSubChannels';
+
+const convertMessagePreviewSetting = (
+  chatSetting: Amity.ChatSettings,
+): Amity.MessagePreviewSetting => {
+  if (!chatSetting.messagePreview.enabled) return Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW;
+
+  if (!chatSetting.messagePreview.isIncludeDeleted)
+    return Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED;
+
+  return Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED;
+};
+
+/**
+ * ```js
+ * import { getMessagePreviewSetting } from '@amityco/ts-sdk'
+ * const messagePreviewSetting = await getMessagePreviewSetting();
+ * ```
+ *
+ * A util to getMessagePreviewSetting from cache or fetch from server
+ * @returns A a {@link Amity.MessagePreviewSetting} enum
+ *
+ * @category private
+ * @async
+ */
+export const getMessagePreviewSetting = async (
+  refresh = true,
+): Promise<Amity.MessagePreviewSetting> => {
+  const messagePreviewSetting = pullFromCache<Amity.MessagePreviewSetting>([
+    'MessagePreviewSetting',
+  ])?.data;
+
+  if (!refresh && messagePreviewSetting) return messagePreviewSetting;
+
+  const newChatSettings = await getChatSettings();
+  const newMessagePreviewSetting = convertMessagePreviewSetting(newChatSettings);
+
+  return newMessagePreviewSetting;
+};
+
+/**
+ * get messagePreviewSetting from cache and compare with new messagePreviewSetting
+ * if new messagePreviewSetting is different from cache, check setting and update data in cache
+ * @returns void
+ *
+ * @category private
+ * @async
+ */
+export const initializeMessagePreviewSetting = async () => {
+  const newMessagePreviewSetting = await getMessagePreviewSetting();
+
+  const messagePreviewSetting = pullFromCache<Amity.MessagePreviewSetting>([
+    'MessagePreviewSetting',
+  ])?.data;
+
+  if (newMessagePreviewSetting === messagePreviewSetting) return;
+
+  pushToCache(['MessagePreviewSetting'], newMessagePreviewSetting);
+
+  const channelWithIsDeletedTrue: Amity.Channel['channelId'][] = [];
+  const subChannelWithIsDeletedTrue: Amity.SubChannel['subChannelId'][] = [];
+
+  if (newMessagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) {
+    /* remove alll messagePreview cache */
+    const messagePreviewCache = queryCache<Amity.InternalMessagePreview>(['MessagePreview']);
+    if (messagePreviewCache && messagePreviewCache?.length > 0) {
+      messagePreviewCache.forEach(({ key, data }) => {
+        dropFromCache(key);
+
+        if (key.includes('MessagePreviewChannel')) {
+          channelWithIsDeletedTrue.push(data.channelId);
+        }
+
+        if (key.includes('MessagePreviewSubChannel')) {
+          subChannelWithIsDeletedTrue.push(data.subChannelId);
+        }
+      });
+    }
+  } else if (
+    newMessagePreviewSetting === Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED
+  ) {
+    /* remove messagePreview cache which isDelete = true */
+    const messagePreviewCache = queryCache<Amity.InternalMessagePreview>(['MessagePreview']);
+    if (messagePreviewCache && messagePreviewCache?.length > 0) {
+      messagePreviewCache.forEach(({ key, data }) => {
+        if (data?.isDeleted) {
+          dropFromCache(key);
+          if (key.includes('MessagePreviewChannel')) {
+            channelWithIsDeletedTrue.push(data.channelId);
+          }
+
+          if (key.includes('MessagePreviewSubChannel')) {
+            subChannelWithIsDeletedTrue.push(data.subChannelId);
+          }
+        }
+      });
+    }
+
+    /**
+     * update messagePreviewId in case of
+     * 1. message preview is disabled and there is messagePreviewId in cache
+     * 2. channel and subChannel which isDelete = true
+     */
+
+    if (channelWithIsDeletedTrue.length !== 0) await getChannelByIds(channelWithIsDeletedTrue);
+
+    if (subChannelWithIsDeletedTrue.length !== 0)
+      await getSubChannelByIds(subChannelWithIsDeletedTrue);
+  }
+};

package/src/client/utils/modifyMqttConnection.ts

@@ -0,0 +1,23 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { getActiveUser } from '~/client/api/activeUser';
+import { proxyMqttEvents } from '~/core/events';
+
+let mqttAccessToken: string;
+let mqttUserId: string;
+
+export async function modifyMqttConnection() {
+  const { mqtt, emitter, token } = getActiveClient();
+  if (!mqtt) return;
+
+  const accessToken = token?.accessToken ?? '';
+
+  const user = getActiveUser();
+
+  if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
+    mqttAccessToken = accessToken!;
+    mqttUserId = user._id!;
+
+    await mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
+    proxyMqttEvents(mqtt, emitter);
+  }
+}

package/src/client/utils/onOffline.ts

@@ -0,0 +1,15 @@
+export const onOffline = (callback: () => void) => {
+  if (typeof window !== 'undefined' && window.addEventListener) {
+    window.addEventListener('offline', callback);
+    return () => window.removeEventListener('offline', callback);
+  }
+
+  if (typeof document !== 'undefined' && document.addEventListener) {
+    document.addEventListener('offline', callback);
+    return () => document.removeEventListener('offline', callback);
+  }
+
+  // Handle unsupported environment
+  console.error('Unsupported environment');
+  return () => console.error('Unsupported environment');
+};

package/src/client/utils/onOnline.ts

@@ -0,0 +1,15 @@
+export const onOnline = (callback: () => void) => {
+  if (typeof window !== 'undefined' && window.addEventListener) {
+    window.addEventListener('online', callback);
+    return () => window.removeEventListener('online', callback);
+  }
+
+  if (typeof document !== 'undefined' && document.addEventListener) {
+    document.addEventListener('online', callback);
+    return () => document.removeEventListener('online', callback);
+  }
+
+  // Handle unsupported environment
+  console.error('Unsupported environment');
+  return () => console.error('Unsupported environment');
+};

package/src/client/utils/removeChannelMarkerCache.ts

@@ -0,0 +1,13 @@
+import { dropFromCache } from '~/cache/api/dropFromCache';
+import { getResolver } from '~/core/model';
+
+import { getActiveUser } from '../api/activeUser';
+
+export const removeChannelMarkerCache = (channel: Amity.StaticInternalChannel) => {
+  const id = getResolver('channelMarker')({
+    userId: getActiveUser()._id,
+    entityId: channel.channelId,
+  });
+
+  dropFromCache(['channelMarker', 'get', id], true);
+};

package/src/client/utils/setBotClientToken.ts

@@ -0,0 +1,35 @@
+import { getActiveClient } from '../api/activeClient';
+import { setSessionState } from '../api/setSessionState';
+import { getBotToken } from '../api/getBotToken';
+
+/**
+ * A util to set or refresh client token
+ * @param options get bot token options
+ * @param options.setAccessTokenCookie The authentication token - necessary when network option is set to secure
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+export const setBotClientToken = async (params: Parameters<typeof getBotToken>[0]) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const { accessToken, users, expiresAt, issuedAt, userType } = await getBotToken(params);
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users, userType };
+};

package/src/client/utils/setClientToken.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '../api/activeClient';
+import { setSessionState } from '../api/setSessionState';
+import { getToken } from '../api/getToken';
+
+/**
+ * A util to set or refresh client token
+ *
+ * @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 token & user info
+ *
+ * @category private
+ * @async
+ */
+export const setClientToken = async (params: Parameters<typeof getToken>[0]) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const { accessToken, users, expiresAt, issuedAt, userType } = await getToken(params);
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.upload.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.upload.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users, userType };
+};

package/src/client/utils/setCurrentUser.ts

@@ -0,0 +1,15 @@
+import { setActiveUser } from '../api/activeUser';
+import { setCurrentUserType } from '../api/getCurrentUserType';
+import { pushToCache } from '~/cache/api/pushToCache';
+
+export const setCurrentUser = ({
+  user,
+  userType,
+}: {
+  user: Amity.RawUser;
+  userType: Amity.UserType;
+}) => {
+  setActiveUser(user);
+  setCurrentUserType(userType);
+  pushToCache(['user', 'get', user.userId], user);
+};

package/src/client/utils/setVisitorClientToken.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '../api/activeClient';
+import { setSessionState } from '../api/setSessionState';
+import { getVisitorToken } from '../api/getVisitorToken';
+
+/**
+ * A util to set or refresh client token
+ *
+ * @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
+ * @param options get bot token options
+ * @param options.setAccessTokenCookie The authentication token - necessary when network option is set to secure
+ * @returns token & user info
+ *
+ * @category private
+ * @async
+ */
+export const setVisitorClientToken = async (params: Parameters<typeof getVisitorToken>[0]) => {
+  const client = getActiveClient();
+  // begin establishing session
+  setSessionState(Amity.SessionStates.ESTABLISHING);
+
+  const { accessToken, users, expiresAt, issuedAt, userType } = await getVisitorToken(params);
+
+  // manually setup the token for http transport
+  client.http.defaults.headers.common.Authorization = `Bearer ${accessToken}`;
+
+  client.http.defaults.metadata = {
+    tokenExpiry: expiresAt,
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users, userType };
+};

package/src/client/utils/subscribeGlobalTopic.ts

@@ -0,0 +1,28 @@
+import { getActiveUser } from '~/client/api/activeUser';
+import {
+  getMarkerUserFeedTopic,
+  getNetworkTopic,
+  getSmartFeedChannelTopic,
+  getSmartFeedMessageTopic,
+  getSmartFeedSubChannelTopic,
+  getUserTopic,
+  subscribeTopic,
+  getLiveStreamTopic,
+} from '~/core/subscription';
+
+export const subscribeGlobalTopic = () => {
+  const disposers: Amity.Unsubscriber[] = [
+    subscribeTopic(getNetworkTopic()),
+    subscribeTopic(getSmartFeedChannelTopic()),
+    subscribeTopic(getSmartFeedSubChannelTopic()),
+    subscribeTopic(getSmartFeedMessageTopic()),
+
+    // subscribing to user topic is necessary to handle ban event
+    subscribeTopic(getUserTopic(getActiveUser())),
+    subscribeTopic(getMarkerUserFeedTopic()),
+
+    subscribeTopic(getLiveStreamTopic()),
+  ];
+
+  return () => disposers.forEach(fn => fn());
+};