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

package/src/channelRepository/utils/getSubChannelsUnreadCount.ts

@@ -1,51 +0,0 @@
-import { pullFromCache } from '~/cache/api/pullFromCache';
-import { getActiveClient } from '~/client/api/activeClient';
-import { getActiveUser } from '~/client/api/activeUser';
-import { getResolver } from '~/core/model';
-
-const getCachedMarker = (entityId: string) => {
-  const key = {
-    entityId,
-    userId: getActiveUser()._id,
-  };
-
-  return pullFromCache<Amity.ChannelMarker>([
-    'channelMarker',
-    'get',
-    getResolver('channelMarker')(key),
-  ])?.data;
-};
-
-const getUnreadInfoCached = (channelId: Amity.RawChannel['channelId']) => {
-  return pullFromCache<Amity.ChannelUnreadInfo>(['channelUnreadInfo', 'get', channelId])?.data;
-};
-
-/**
- * The function use to get value of unreadCount field.
- * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
- *
- * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
- * If not, the function will return the value from the channelMarker cache.
- * If not found in the both cache, use `0` as defaul value.
- */
-
-export const getSubChannelsUnreadCount = (
-  channel: Omit<Amity.RawChannel, 'messageCount'>,
-  marker?: Amity.ChannelMarker,
-) => {
-  const client = getActiveClient();
-
-  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-    // Marker service API uses channelInternalId as channelId
-    return getUnreadInfoCached(channel.channelInternalId)?.unreadCount ?? 0;
-  }
-
-  if (marker?.isDeleted) {
-    // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
-    // leave the channel because currently backend can't handle this, so every time a user is banned
-    // from a channel or the channel is deleted the channel's unread count will reset to zero
-    return 0;
-  }
-
-  return marker?.unreadCount ?? getCachedMarker(channel.channelInternalId)?.unreadCount ?? 0;
-};

package/src/channelRepository/utils/index.ts

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

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -1,159 +0,0 @@
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertRawMembershipToMembership } from '~/group/utils/withUser';
-import { getChannelMarkers } from '~/marker/api/getChannelMarkers';
-
-import { updateChannelMessagePreviewCache } from '~/messagePreview/utils';
-import { getActiveClient } from '~/client/api/activeClient';
-import { pullFromCache } from '~/cache/api/pullFromCache';
-import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
-import { pushToCache } from '~/cache/api';
-import { fireEvent } from '~/core/events';
-
-export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
-export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
-  MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
-
-export function convertFromRaw(
-  channel: Amity.RawChannel,
-  options: { isMessagePreviewUpdated?: boolean } = { isMessagePreviewUpdated: true },
-): Amity.StaticInternalChannel {
-  let { messagePreviewId } = channel;
-
-  const messagePreviewChannelCache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewChannel',
-    'get',
-    channel.channelId,
-  ])?.data;
-
-  if (messagePreviewChannelCache?.messagePreviewId && !options.isMessagePreviewUpdated) {
-    messagePreviewId = messagePreviewChannelCache.messagePreviewId;
-  }
-
-  return {
-    ...channel,
-    defaultSubChannelId: channel.channelInternalId,
-    isUnreadCountSupport: isUnreadCountSupport(channel),
-    messagePreviewId,
-  };
-}
-
-export const preUpdateChannelCache = (
-  rawPayload: Amity.ChannelPayload,
-  options: { isMessagePreviewUpdated?: boolean } = { isMessagePreviewUpdated: true },
-) => {
-  ingestInCache({
-    channels: rawPayload.channels.map(channel =>
-      convertFromRaw(channel, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }),
-    ),
-  });
-};
-
-const updateChannelUnread = ({
-  currentUserId,
-  channels,
-  channelUsers,
-}: {
-  currentUserId: Amity.User['userId'];
-  channels: Amity.RawChannel[];
-  channelUsers: Amity.RawMembership<'channel'>[];
-}) => {
-  const channelsUnread: Amity.ChannelUnread[] = [];
-
-  for (let i = 0; i < channels.length; i += 1) {
-    const cacheKey = ['channelUnread', 'get', channels[i].channelId];
-    const channelUser = channelUsers.find(
-      channelUser =>
-        channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId,
-    );
-
-    let unreadCount = 0;
-    let readToSegment = null;
-    let lastMentionedSegment = null;
-    let isMentioned = false;
-
-    if (channelUser) {
-      readToSegment = channelUser.readToSegment;
-      lastMentionedSegment = channelUser.lastMentionedSegment;
-      unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
-      isMentioned = lastMentionedSegment > readToSegment;
-    }
-
-    const cacheChannelUnread: Amity.ChannelUnread = {
-      channelId: channels[i].channelId,
-      lastSegment: channels[i].messageCount,
-      readToSegment,
-      lastMentionedSegment,
-      unreadCount,
-      isMentioned,
-      isDeleted: channels[i].isDeleted || false,
-    };
-    pushToCache(cacheKey, cacheChannelUnread);
-
-    channelsUnread.push(cacheChannelUnread);
-  }
-  fireEvent('local.channelUnread.updated', channelsUnread);
-};
-
-export const prepareChannelPayload = async (
-  rawPayload: Amity.ChannelPayload,
-  options: { isMessagePreviewUpdated?: boolean } = { isMessagePreviewUpdated: true },
-): Promise<Amity.ProcessedChannelPayload> => {
-  const client = getActiveClient();
-  const networkPreviewSetting = await client.getMessagePreviewSetting(false);
-
-  if (
-    options.isMessagePreviewUpdated &&
-    networkPreviewSetting !== Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW &&
-    rawPayload.messagePreviews &&
-    rawPayload.messagePreviews.length > 0
-  ) {
-    updateChannelMessagePreviewCache(rawPayload);
-  }
-
-  if (client.useLegacyUnreadCount) {
-    updateChannelUnread({
-      channels: rawPayload.channels,
-      channelUsers: rawPayload.channelUsers,
-      currentUserId: client.userId!,
-    });
-  } else {
-    const markerIds = rawPayload.channels
-      // filter channel by type. Only conversation, community and broadcast type are included.
-      .filter(isUnreadCountSupport)
-      .map(({ channelInternalId }) => channelInternalId);
-
-    if (markerIds.length > 0) {
-      // since the get markers method requires a channel cache to function with the reducer.
-      preUpdateChannelCache(rawPayload, {
-        isMessagePreviewUpdated: options.isMessagePreviewUpdated,
-      });
-
-      try {
-        await getChannelMarkers(markerIds);
-      } catch (e) {
-        // empty block (from the spec, allow marker fetch to fail without having to do anything)
-      }
-    }
-  }
-
-  // convert raw channel to internal channel
-  const channels = rawPayload.channels.map(payload =>
-    convertFromRaw(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }),
-  );
-
-  // convert raw channel user to membership (add user object)
-  const channelUsers: Amity.Membership<'channel'>[] = rawPayload.channelUsers.map(channelUser => {
-    return convertRawMembershipToMembership<'channel'>(channelUser);
-  });
-
-  const users = rawPayload.users.map(convertRawUserToInternalUser);
-
-  const { messageFeedsInfo, messagePreviews, ...restRawPayload } = rawPayload;
-
-  return {
-    ...restRawPayload,
-    users,
-    channels,
-    channelUsers,
-  };
-};

package/src/channelRepository/utils/prepareUnreadCountInfo.ts

@@ -1,21 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
-import { persistUnreadCountInfo } from '~/marker/utils/persistUnreadCountInfo';
-
-export const prepareUnreadCountInfo = async (rawPayload: Amity.ChannelPayload) => {
-  const client = getActiveClient();
-  // if consistent mode is enabled, persist the unread count info to the cache
-
-  // Marker service API uses channelInternalId as channelId
-  const queryPayload = await getUserMessageFeedMakers(
-    rawPayload.channels.map(({ channelInternalId }) => channelInternalId),
-  );
-
-  const { feedMarkers, userFeedMarkers } = queryPayload;
-  persistUnreadCountInfo({
-    feedMarkers,
-    userFeedMarkers,
-  });
-
-  client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
-};

package/src/channelRepository/utils/resolveChannels.ts

@@ -1,13 +0,0 @@
-import { queryCache } from '~/cache/api';
-import { getChannelByIds } from '../internalApi/getChannelByIds';
-import { fireEvent } from '~/core/events';
-
-export const resolveChannels = async (channelIds: Amity.InternalChannel['channelPublicId'][]) => {
-  await getChannelByIds(channelIds);
-  const channels =
-    queryCache<Amity.StaticInternalChannel>(['channel', 'get'])
-      ?.filter(({ data }) => data.channelPublicId && channelIds.includes(data.channelPublicId))
-      ?.map(({ data }) => data) ?? [];
-
-  fireEvent('local.channel.resolved', channels);
-};

package/src/channelRepository/utils/resolveUnreadInfoOnChannelEvent.ts

@@ -1,12 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import ObjectResolverEngine from '~/client/utils/ObjectResolver/objectResolverEngine';
-
-export const resolveUnreadInfoOnChannelEvent = (channel: Amity.StaticInternalChannel) => {
-  const client = getActiveClient();
-
-  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-    const objectResolverEngine = ObjectResolverEngine.getInstance();
-
-    objectResolverEngine.resolve(channel.channelId, Amity.ReferenceType.USER_MESSAGE_FEED_MARKER);
-  }
-};

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

@@ -1,146 +0,0 @@
-import { disableCache, enableCache, pushToCache } from '~/cache/api';
-import { ASCApiError } from '~/core/errors';
-import {
-  generateChannelMarker,
-  connectClient,
-  disconnectClient,
-  generateRawChannel,
-  generateRawChannelUser,
-  convertChannelUserFromRaw,
-} from '~/utils/tests';
-
-import * as getChannelMarkers from '../../../marker/api/getChannelMarkers';
-import { isUnreadCountSupport, MARKER_INCLUDED_CHANNEL_TYPE, prepareChannelPayload } from '..';
-
-export const communityChannel: Amity.RawChannel = generateRawChannel({
-  channelId: 'ch1',
-  type: 'community',
-});
-export const liveChannel: Amity.RawChannel = generateRawChannel({
-  channelId: 'ch2',
-  type: 'live',
-});
-export const conversationChannel: Amity.RawChannel = generateRawChannel({
-  channelId: 'ch3',
-  type: 'conversation',
-});
-
-export const rawChannelUser = generateRawChannelUser();
-
-export const channelUser = convertChannelUserFromRaw(rawChannelUser, undefined);
-
-const channelMarker1 = generateChannelMarker({
-  entityId: communityChannel.channelId,
-  userId: 'user1',
-});
-
-const channelMarker2 = generateChannelMarker({
-  entityId: conversationChannel.channelId,
-  userId: 'user1',
-});
-
-const resolvedChannelMarkers: Amity.Cached<Amity.Paged<Amity.ChannelMarker>> = {
-  data: [channelMarker1, channelMarker2],
-  cachedAt: Date.now(),
-};
-
-const channelPayload: Amity.ChannelPayload = {
-  channels: [communityChannel, liveChannel, conversationChannel],
-  channelUsers: [rawChannelUser],
-  users: [],
-  files: [],
-  messagePreviews: [],
-};
-
-const convertedChannelPayload: Amity.ProcessedChannelPayload = {
-  channels: [
-    {
-      ...communityChannel,
-      defaultSubChannelId: communityChannel._id,
-      isUnreadCountSupport: true,
-      unreadCount: channelMarker1.unreadCount,
-      hasMentioned: channelMarker1.hasMentioned,
-      isMentioned: channelMarker1.hasMentioned,
-      messagePreviewId: undefined,
-      subChannelsUnreadCount: channelMarker1.unreadCount,
-    },
-    {
-      ...liveChannel,
-      defaultSubChannelId: liveChannel._id,
-      isUnreadCountSupport: false,
-      unreadCount: 0,
-      hasMentioned: false,
-      isMentioned: false,
-      messagePreviewId: undefined,
-      subChannelsUnreadCount: 0,
-    },
-    {
-      ...conversationChannel,
-      defaultSubChannelId: conversationChannel._id,
-      isUnreadCountSupport: true,
-      unreadCount: channelMarker2.unreadCount,
-      hasMentioned: channelMarker2.hasMentioned,
-      isMentioned: channelMarker2.hasMentioned,
-      messagePreviewId: undefined,
-      subChannelsUnreadCount: channelMarker2.unreadCount,
-    },
-  ],
-  channelUsers: [channelUser],
-  users: [],
-  files: [],
-};
-
-describe('prepareChannelPayload', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  it('should map channel payload with marker correctly', async () => {
-    jest
-      .spyOn(getChannelMarkers, 'getChannelMarkers')
-      .mockResolvedValueOnce(resolvedChannelMarkers);
-
-    const { channels: received } = await prepareChannelPayload(channelPayload);
-
-    expect(received).toEqual(convertedChannelPayload.channels);
-  });
-
-  it('should map channel payload with marker cache correctly', async () => {
-    pushToCache(['channelMarker', 'get', channelMarker1.entityId], channelMarker1);
-    pushToCache(['channelMarker', 'get', channelMarker2.entityId], channelMarker2);
-
-    const { channels: received } = await prepareChannelPayload(channelPayload);
-
-    expect(received).toEqual(convertedChannelPayload.channels);
-  });
-
-  it('should map channel payload with `unreadCount: 0` on unable to fetch marker', async () => {
-    const { channels: received } = await prepareChannelPayload(channelPayload);
-
-    const expected = convertedChannelPayload.channels.map(c => ({ ...c, unreadCount: 0 }));
-
-    expect(received).toEqual(expected);
-  });
-
-  it(`should filter channels by ${MARKER_INCLUDED_CHANNEL_TYPE.join(', ')} type(s)`, async () => {
-    const mock = jest
-      .spyOn(getChannelMarkers, 'getChannelMarkers')
-      .mockResolvedValueOnce(resolvedChannelMarkers);
-
-    await prepareChannelPayload(channelPayload);
-
-    const expected = channelPayload.channels.filter(isUnreadCountSupport).map(c => c.channelId);
-
-    expect(mock).toHaveBeenCalledWith(expected);
-  });
-
-  it('should not throw an error on `getChannelMarkers` failed', async () => {
-    jest
-      .spyOn(getChannelMarkers, 'getChannelMarkers')
-      .mockRejectedValueOnce(new ASCApiError('error', 500, Amity.ErrorLevel.ERROR));
-
-    await expect(prepareChannelPayload(channelPayload)).resolves.not.toThrow();
-  });
-});

package/src/channelRepository/utils/updateChannelCache.ts

@@ -1,13 +0,0 @@
-import { pushToCache } from '~/cache/api';
-import { shallowClone } from '~/utils/shallowClone';
-
-export function updateChannelCache(
-  channel: Amity.StaticInternalChannel,
-  params: Partial<Amity.StaticInternalChannel>,
-) {
-  pushToCache(
-    ['channel', 'get', channel.channelId],
-    // eslint-disable-next-line prefer-object-spread
-    shallowClone(channel, params),
-  );
-}

package/src/client/api/accessTokenExpiryWatcher.ts

@@ -1,90 +0,0 @@
-import { fireEvent } from '~/core/events';
-import { scheduleTask } from '~/core/microtasks';
-import { MINUTE, ACCESS_TOKEN_WATCHER_INTERVAL } from '~/utils/constants';
-
-import { renewal } from './renewal';
-import { getActiveClient } from './activeClient';
-
-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 = (
-  sessionHandler: Amity.SessionHandler,
-): Amity.Unsubscriber => {
-  const interval: ReturnType<typeof setInterval> = setInterval(() => {
-    const client = getActiveClient();
-
-    if (!client.token) return;
-
-    const { issuedAt, expiresAt } = client.token;
-
-    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,33 +0,0 @@
-import { ASCError } from '~/core/errors';
-
-let activeClient: Amity.Client | null = null;
-
-/**
- * Get the active client
- *
- * @returns the active client instance
- *
- * @hidden
- */
-export const getActiveClient = () => {
-  if (!activeClient) {
-    throw new ASCError(
-      'There is no active client',
-      Amity.ClientError.UNKNOWN_ERROR,
-      Amity.ErrorLevel.FATAL,
-    );
-  }
-
-  return activeClient!;
-};
-
-/**
- * Sets the active client
- *
- * @param client the client to assume as currently active client
- *
- * @hidden
- */
-export const setActiveClient = (client: Amity.Client) => {
-  activeClient = client;
-};

package/src/client/api/activeUser.ts

@@ -1,31 +0,0 @@
-import { ASCError } from '~/core/errors';
-
-let activeUser: Amity.ActiveUser | null = null;
-
-/* begin_public_function
-  id: client.get_current_user
-*/
-/**
- * for internal use
- * @deprecated please use getCurrentUser api instead.
- */
-export const getActiveUser = () => {
-  if (!activeUser) {
-    throw new ASCError(
-      'Connect client first',
-      Amity.ClientError.UNKNOWN_ERROR,
-      Amity.ErrorLevel.FATAL,
-    );
-  }
-
-  return activeUser!;
-};
-/* end_public_function */
-
-export const setActiveUser = (user: Amity.ActiveUser) => {
-  activeUser = {
-    _id: user._id,
-    userId: user.userId,
-    path: user.path,
-  };
-};