@amityco/ts-sdk 6.35.3-f8f74ab5.0 → 6.35.3

package/src/client/utils/markerSyncEngine.ts

@@ -0,0 +1,252 @@
+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 { enableUnreadCount } from '../api/enableUnreadCount';
+
+import { onOnline } from './onOnline';
+import { onUserFeedMarkerUpdated } from '~/marker/events/onUserFeedMarkerUpdated';
+import { getActiveClient } from '~/client/api/activeClient';
+import { getChatSettings } from '../api/getChatSettings';
+
+const SYNC_TRIGGER_INTERVAL_TIME = 2000;
+const ON_SUB_CHANNEL_DELETE_SYNC_TRIGGER_DELAY = 2000;
+
+let isSyncRunning = false;
+let disposers: (() => void)[] = [];
+let isWaitingForResponse = false;
+
+let 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 () => {
+  // check the chat setting, if marker enabled is false, should not start marker syncing
+  const setting = await getChatSettings();
+  if (!setting.marker?.enabled) return;
+
+  await fetchDeviceLastSyncAt();
+  pushMarkerSyncEvent(Amity.MarkerSyncEvent.START_SYNCING);
+
+  isConsistentMode = true;
+  isSyncRunning = true;
+
+  registerEventListeners();
+
+  return unRegisterEventListeners;
+};
+
+/**
+ ```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 () => {
+  await fetchDeviceLastSyncAt();
+  pushMarkerSyncEvent(Amity.MarkerSyncEvent.START_SYNCING);
+
+  enableUnreadCount();
+
+  isConsistentMode = false;
+  isSyncRunning = true;
+
+  registerEventListeners();
+};
+
+/**
+ ```js
+ * import { stopUnreadSync } from '@amityco/ts-sdk'
+ * stopUnreadSync()
+ * ```
+ *
+ * stop unread syncing
+ *
+ * @category Marker API
+ */
+export const stopUnreadSync = () => {
+  isSyncRunning = false;
+  setMarkerSyncEvents([]);
+  unRegisterEventListeners();
+};
+
+/**
+ * @deprecated Please use `startUnreadSync` instead
+ */
+export const stopUnreadSyncing = () => {
+  console.warn('`stopUnreadSyncing` has been deprecated, please use `stopUnreadSync` instead');
+
+  return stopUnreadSync();
+};
+
+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/setClientToken.ts

@@ -0,0 +1,41 @@
+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 } = 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,
+  };
+
+  // manually setup the token for ws transport
+  if (client.ws) client.ws.io.opts.query = { token: accessToken };
+
+  client.token = { accessToken, issuedAt, expiresAt };
+
+  setSessionState(Amity.SessionStates.ESTABLISHED);
+
+  return { accessToken, users };
+};

package/src/client/utils/subscribeGlobalTopic.ts

@@ -0,0 +1,25 @@
+import { getActiveUser } from '~/client/api/activeUser';
+import {
+  getMarkerUserFeedTopic,
+  getNetworkTopic,
+  getSmartFeedChannelTopic,
+  getSmartFeedMessageTopic,
+  getSmartFeedSubChannelTopic,
+  getUserTopic,
+  subscribeTopic,
+} 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()),
+  ];
+
+  return () => disposers.forEach(fn => fn());
+};

package/src/commentRepository/api/createComment.ts

@@ -0,0 +1,112 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { getPost } from '~/postRepository/api/getPost';
+import { LinkedObject } from '~/utils/linkedObject';
+import { pullFromCache } from '~/cache/api';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+
+/* begin_public_function
+  id: comment.create
+*/
+/**
+ * ```js
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const newComment = await CommentRepository.createComment(bundle)
+ * ```
+ *
+ * Creates an {@link Amity.Comment}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Comment}
+ * @returns The newly created {@link Amity.Comment}
+ *
+ * @category Comment API
+ * @async
+ */
+export const createComment = async (
+  bundle: Pick<
+    Amity.Comment<Amity.CommentContentType>,
+    | 'data'
+    | 'referenceType'
+    | 'referenceId'
+    | 'parentId'
+    | 'metadata'
+    | 'mentionees'
+    | 'attachments'
+  >,
+): Promise<Amity.Cached<Amity.Comment>> => {
+  const client = getActiveClient();
+  client.log('comment/createComment', bundle);
+
+  const { data } = await client.http.post<Amity.CommentPayload>('/api/v3/comments', bundle);
+
+  const { comments } = data;
+
+  // BE always returns an array of comments If it got record 0 from BE it might have a problem on creation logic
+  if (comments.length === 0) throw new Error('Comment not created');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  if (['post', 'content'].includes(bundle.referenceType)) {
+    const post = pullFromCache<Amity.Post>(['post', 'get', bundle.referenceId])?.data;
+
+    if (post) {
+      post.commentsCount += 1;
+
+      fireEvent('local.post.updated', {
+        posts: [post],
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: data.communityUsers,
+        feeds: [],
+        files: data.files,
+        postChildren: [],
+        users: data.users,
+        videoStreamings: [],
+      });
+    }
+  } else if (bundle.referenceType === 'story') {
+    const storyIndex = pullFromCache<Amity.Story['referenceId']>([
+      STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID,
+      bundle.referenceId,
+    ]);
+
+    if (storyIndex?.data) {
+      const cacheStory = pullFromCache<Amity.InternalStory>([
+        STORY_KEY_CACHE.STORY,
+        'get',
+        storyIndex.data,
+      ]);
+
+      if (cacheStory?.data) {
+        fireEvent('story.updated', {
+          stories: [
+            {
+              ...cacheStory.data,
+              commentsCount: cacheStory.data.commentsCount + 1,
+              comments: [...new Set([...cacheStory.data.comments, comments[0].commentId])],
+            },
+          ],
+          categories: [],
+          comments,
+          communities: [],
+          communityUsers: data.communityUsers,
+          files: data.files,
+          users: data.users,
+        });
+      }
+    }
+  }
+
+  fireEvent('local.comment.created', data);
+
+  return {
+    data: LinkedObject.comment(comments[0]),
+    cachedAt,
+  };
+};
+/* end_public_function */