@amityco/ts-sdk-react-native 6.17.0 → 6.17.3

package/src/channelRepository/observers/{getChannels.ts → getChannels/getChannels.ts}

@@ -3,7 +3,7 @@
 import { dropFromCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { ChannelLiveCollectionController } from './liveCollection/ChannelLiveCollectionController';
+import { ChannelLiveCollectionController } from './ChannelLiveCollectionController';
 
 /* begin_public_function
   id: channel.query

package/src/channelRepository/observers/getChannels/index.ts

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

package/src/client/api/createClient.ts

@@ -12,9 +12,10 @@ import {
 import { createEventEmitter } from '~/core/events';
 
 import { getMessagePreviewSetting } from '~/client/utils/messagePreviewEngine';
+import { getSocialSettings } from '~/client/api/getSocialSettings';
+import { hasPermission } from '~/client/utils/hasPermission';
 import { getActiveClient, setActiveClient } from './activeClient';
 import { getFeedSettings } from './getFeedSettings';
-import { getSocialSettings } from '~/client/api/getSocialSettings';
 
 import { accessTokenExpiryWatcher } from './accessTokenExpiryWatcher';
 
@@ -96,6 +97,7 @@ export const createClient = (
     accessTokenExpiryWatcher,
     sessionHandler,
 
+    hasPermission,
     getFeedSettings,
     getSocialSettings,
     getMessagePreviewSetting,

package/src/client/api/login.ts

@@ -25,6 +25,7 @@ import { onTokenTerminated } from '../events/onTokenTerminated';
 import { setClientToken } from '../utils/setClientToken';
 import { removeChannelMarkerCache } from '../utils/removeChannelMarkerCache';
 import { initializeMessagePreviewSetting } from '../utils/messagePreviewEngine';
+import { ASCError } from '~/core/errors';
 
 /*
  * declared earlier to accomodate case when logging in with a different user
@@ -84,12 +85,34 @@ export const login = async (
   }
 
   // default values
-  params.deviceId ??= await getDeviceId();
+  const defaultDeviceId = await getDeviceId();
 
   try {
-    // @ts-ignore: in that particular case, typing can be
-    // ignored since we enforce default values just before.
-    const { users } = await setClientToken(params);
+    const { users } = await setClientToken({
+      ...params,
+      displayName: params?.displayName || params.userId,
+      deviceId: params?.deviceId || defaultDeviceId,
+    });
+
+    const user = users.find(u => u.userId === params.userId);
+
+    if (user == null) {
+      throw new ASCError(
+        `${params.userId} has not been founded`,
+        Amity.ClientError.UNKNOWN_ERROR,
+        Amity.ErrorLevel.ERROR,
+      );
+    }
+
+    if (user.isDeleted) {
+      terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+      return false;
+    }
+
+    if (user.isGlobalBanned) {
+      terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
+      return false;
+    }
 
     // FIXME: events are duplicated if connectClient is called few times without disconnectClient
     // wire websocket events to our event emitter
@@ -99,7 +122,7 @@ export const login = async (
       client.ws.open();
     });
 
-    client.userId = params.userId;
+    client.userId = user.userId;
 
     client.sessionHandler = sessionHandler;
 
@@ -113,7 +136,7 @@ export const login = async (
       sessionHandler!,
     );
 
-    setActiveUser(users[0]);
+    setActiveUser(user);
   } catch (error) {
     /*
      * if getting token failed session state reverts to initial state when app

package/src/client/api/logout.ts

@@ -53,6 +53,11 @@ export const logout = async (): Promise<boolean> => {
   client.token = undefined;
 
   client.http.defaults.headers.common.Authorization = '';
+  client.http.defaults.metadata = {
+    tokenExpiry: '',
+    isGlobalBanned: false,
+    isUserDeleted: false,
+  };
   client.ws.io.opts.query = { token: '' };
 
   /*

package/src/client/observers/getTotalUnreadCount.ts

@@ -1,6 +1,6 @@
 import { ASCError } from '~/core/errors';
 import { getUserMarker } from '~/marker/api';
-import { onUserMarkerFetched } from '~/marker/events';
+import { onUserMarkerFetchedLegacy } from '~/marker/events';
 import { liveObject } from '~/utils/liveObject';
 
 import { getActiveUser } from '../api';
@@ -37,7 +37,17 @@ export const getTotalUnreadCount = (
 
   const callbackDataSelector = (data: Amity.UserMarker | undefined) => data?.unreadCount ?? 0;
 
-  return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
-    callbackDataSelector,
-  });
+  return liveObject(
+    userId,
+    callback,
+    'userId',
+    async (): Promise<Amity.Cached<Amity.UserMarker>> => {
+      const { data: userMarker, cachedAt } = await getUserMarker();
+      return { data: userMarker as Amity.UserMarker, cachedAt };
+    },
+    [onUserMarkerFetchedLegacy],
+    {
+      callbackDataSelector,
+    },
+  );
 };

package/src/client/observers/getUserUnread.ts

@@ -1,9 +1,13 @@
-import { ASCError } from '~/core/errors';
+import { ASCApiError, ASCError } from '~/core/errors';
 import { getUserMarker } from '~/marker/api';
 import { onUserMarkerFetched } from '~/marker/events';
-import { liveObject } from '~/utils/liveObject';
 
-import { getActiveUser } from '../api';
+import { getActiveClient, getActiveUser } from '../api';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
 
 /**
  *
@@ -34,14 +38,94 @@ export const getUserUnread = (
       Amity.ErrorLevel.ERROR,
     );
 
-  const callbackDataSelector = (data: Amity.UserMarker | undefined) => {
-    return {
-      unreadCount: data?.unreadCount ?? 0,
-      hasMentioned: !!data?.hasMentioned,
-    };
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Object feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveUserUnread(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  let isUnsyncedModel = false; // for messages
+
+  const dispatcher = (data: Amity.LiveObject<Amity.UserMarker>) => {
+    const userUnread = data.data;
+
+    callback({
+      data: {
+        hasMentioned: userUnread.hasMentioned,
+        unreadCount: userUnread.unreadCount,
+      },
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (userMarkers: Amity.UserMarker[]) => {
+    const filterUserMarkers = userMarkers.filter(userMarker => userId === userMarker.userId);
+
+    const latestUserMarker = filterUserMarkers.reduce((currentMaxUserMarker, userMarker) => {
+      if (
+        currentMaxUserMarker == null ||
+        new Date(userMarker.lastSyncAt).getTime() >
+          new Date(currentMaxUserMarker.lastSyncAt).getTime()
+      ) {
+        return userMarker;
+      }
+      return currentMaxUserMarker;
+    }, null as Amity.UserMarker | null);
+
+    dispatcher({
+      loading: false,
+      data: {
+        unreadCount: latestUserMarker?.unreadCount ?? 0,
+        hasMentioned: filterUserMarkers.some(userMarker => !!userMarker.hasMentioned),
+      } as Amity.UserMarker,
+    });
   };
 
-  return liveObject(userId, callback, 'userId', getUserMarker, [onUserMarkerFetched], {
-    callbackDataSelector,
-  });
+  function isAmityUserMarkerData(data: unknown): data is Amity.UserMarker {
+    if (data == null) return false;
+    return (data as { data: Amity.UserMarker })?.data != null;
+  }
+
+  const onFetch = () => {
+    const query = createQuery(getUserMarker);
+
+    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+      if (!isAmityUserMarkerData(data)) return;
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedModel = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedModel) {
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(onUserMarkerFetched(userMarkers => realtimeRouter(userMarkers)));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
 };

package/src/client/utils/hasPermission/checkChannelPermission.ts

@@ -0,0 +1,22 @@
+import { pullFromCache } from '~/cache/api';
+import { checkUserPermission } from './checkUserPermission';
+
+export const checkChannelPermission = (
+  userId: Amity.User['userId'] | undefined,
+  permission: string,
+  channelId: Amity.Channel['channelId'],
+) => {
+  if (!userId) return false;
+
+  const member = pullFromCache<Amity.Membership<'channel'>>([
+    'channelUsers',
+    'get',
+    `${channelId}#${userId}`,
+  ])?.data;
+
+  if (!member) return false;
+
+  if (member.permissions.some(x => x === permission)) return true;
+
+  return checkUserPermission(userId, permission);
+};

package/src/client/utils/hasPermission/checkCommunityPermission.ts

@@ -0,0 +1,22 @@
+import { pullFromCache } from '~/cache/api';
+import { checkUserPermission } from './checkUserPermission';
+
+export const checkCommunityPermission = (
+  userId: Amity.User['userId'] | undefined,
+  permission: string,
+  communityId: Amity.Community['communityId'],
+) => {
+  if (!userId) return false;
+
+  const member = pullFromCache<Amity.Membership<'community'>>([
+    'communityUsers',
+    'get',
+    `${communityId}#${userId}`,
+  ])?.data;
+
+  if (!member) return false;
+
+  if (member.permissions.some(x => x === permission)) return true;
+
+  return checkUserPermission(userId, permission);
+};

package/src/client/utils/hasPermission/checkUserPermission.ts

@@ -0,0 +1,12 @@
+import { pullFromCache } from '~/cache/api';
+
+export const checkUserPermission = (
+  userId: Amity.User['userId'] | undefined,
+  permission: string,
+) => {
+  const user = pullFromCache<Amity.User>(['users', 'get', userId])?.data;
+
+  if (!user) return false;
+
+  return user.permissions.some(x => x === permission);
+};

package/src/client/utils/hasPermission/hasPermission.ts

@@ -0,0 +1,18 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { checkCommunityPermission } from '~/client/utils/hasPermission/checkCommunityPermission';
+import { checkChannelPermission } from '~/client/utils/hasPermission/checkChannelPermission';
+import { checkUserPermission } from '~/client/utils/hasPermission/checkUserPermission';
+
+export const hasPermission = (permission: string) => {
+  const { userId } = getActiveClient();
+
+  return {
+    currentUser: () => checkUserPermission(userId, permission),
+
+    community: (communityId: Amity.Community['communityId']) =>
+      checkCommunityPermission(userId, permission, communityId),
+
+    channel: (channelId: Amity.Channel['channelId']) =>
+      checkChannelPermission(userId, permission, channelId),
+  };
+};

package/src/client/utils/hasPermission/index.ts

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

package/src/client/utils/markerSyncEngine.ts

@@ -8,7 +8,7 @@ import { onUserMarkerSync } from '~/marker/events/onUserMarkerSync';
 import { setIntervalTask } from '~/utils/timer';
 import { getUserMarker } from '~/marker/api';
 import { onFeedMarkerUpdated } from '~/marker/events';
-import { onMessageCreated } from '~/messageRepository/events';
+import { onMessageCreatedMqtt } from '~/messageRepository/events';
 import { onSubChannelCreated, onSubChannelDeleted } from '~/subChannelRepository/events';
 import { isUnreadCountSupport } from '~/subChannelRepository/utils';
 
@@ -22,25 +22,27 @@ let isSyncRunning = false;
 let disposers: (() => void)[] = [];
 let isWaitingForResponse = false;
 
-let deviceLastSyncAt: string | null = null;
+let deviceLastSyncAt: Date | null = null;
 
 const getDeviceLastSyncAt = () => {
   if (deviceLastSyncAt == null) {
-    return new Date().toISOString();
+    return new Date();
   }
 
   return deviceLastSyncAt;
 };
 
-const saveDeviceLastSyncAt = (lastSyncAt: string) => {
-  if (!deviceLastSyncAt || new Date(lastSyncAt).getTime() > new Date(deviceLastSyncAt).getTime()) {
+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();
-  saveDeviceLastSyncAt(userMarker.lastSyncAt);
+  if (userMarker == null) return;
+  saveDeviceLastSyncAt(new Date(userMarker.lastSyncAt));
 };
 
 /**
@@ -84,24 +86,41 @@ export const markerSyncTrigger = async () => {
     // no event that require to call marker sync API
     return;
   }
-
-  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());
-
-  saveDeviceLastSyncAt(response.data.userMarkers[0].lastSyncAt);
-
-  if (response.hasMore) {
-    events.push(Amity.MarkerSyncEvent.HAS_MORE);
+  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;
+    }
   }
-
-  // eslint-disable-next-line require-atomic-updates
-  isWaitingForResponse = false;
 };
 
 const registerEventListeners = () => {
@@ -119,15 +138,10 @@ const registerEventListeners = () => {
       events.push(Amity.MarkerSyncEvent.RESUME);
     }),
 
-    onMessageCreated(
-      message => {
-        // only conversation, community and broadcast types can sync
-        if (isUnreadCountSupport(message)) events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
-      },
-      // only trigger sync from remote events to prevent an unread count equal `-1`
-      // when an optimistic message creation is performed.
-      false,
-    ),
+    onMessageCreatedMqtt(message => {
+      // only conversation, community and broadcast types can sync
+      if (isUnreadCountSupport(message)) events.push(Amity.MarkerSyncEvent.NEW_MESSAGE);
+    }),
 
     onChannelCreated(() => events.push(Amity.MarkerSyncEvent.CHANNEL_CREATED)),
     onChannelDeleted(() => events.push(Amity.MarkerSyncEvent.CHANNEL_DELETED)),

package/src/client/utils/setClientToken.ts

@@ -14,7 +14,7 @@ import { getToken } from '../api/getToken';
  * @category private
  * @async
  */
-export const setClientToken = async (params: Parameters<typeof getToken>) => {
+export const setClientToken = async (params: Parameters<typeof getToken>[0]) => {
   const client = getActiveClient();
   // begin establishing session
   setSessionState(Amity.SessionStates.ESTABLISHING);

package/src/communityRepository/communityMembership/events/onCommunityJoined.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityJoined = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.joined', callback);

package/src/communityRepository/communityMembership/events/onCommunityLeft.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityLeft = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.left', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserAdded.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserAdded = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userAdded', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserBanned.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserBanned = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userBanned', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserChanged.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserChanged = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, members: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userChanged', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserRemoved.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserRemoved = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userRemoved', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserRoleAdded.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserRoleAdded = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.roleAdded', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserRoleRemoved.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserRoleRemoved = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.roleRemoved', callback);

package/src/communityRepository/communityMembership/events/onCommunityUserUnbanned.ts

@@ -16,5 +16,5 @@ import { createCommunityMemberEventSubscriber } from './utils';
  * @category Community Events
  */
 export const onCommunityUserUnbanned = (
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
 ) => createCommunityMemberEventSubscriber('community.userUnbanned', callback);

package/src/communityRepository/communityMembership/events/utils.ts

@@ -6,6 +6,7 @@ import { getResolver } from '~/core/model';
 
 import { prepareCommunityPayload } from '../../utils';
 import { updateMembershipStatus } from '../../utils/communityWithMembership';
+import { isNonNullable } from '~/utils';
 
 function hasPermission(
   member: Amity.Membership<'community'>,
@@ -31,30 +32,30 @@ function getEventRelatedMember(
   },
 ) {
   if (event === 'community.joined' || event === 'community.left') {
-    return payload.communityUsers![0];
+    return payload.communityUsers;
   }
 
   // NOTE: backend returns the one who took the action and the one on whom
   // the action was taken. We need the 2nd one
   if (event === 'community.userRemoved') {
-    return payload.communityUsers!.filter(x => x.communityMembership === 'none')[0];
+    return payload.communityUsers!.filter(x => x.communityMembership === 'none');
   }
 
   if (event === 'community.userBanned') {
-    return payload.communityUsers!.filter(x => x.communityMembership === 'banned')[0];
+    return payload.communityUsers!.filter(x => x.communityMembership === 'banned');
   }
 
   // NOTE: it might be that in certain edge cases permission check won't be enough
   if (event === 'community.userUnbanned') {
-    return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'))[0];
+    return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'));
   }
 
-  return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'))[0];
+  return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'));
 }
 
 export const createCommunityMemberEventSubscriber = (
   event: keyof Amity.MqttCommunityUserEvents,
-  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+  callback: (community: Amity.Community, members: Amity.Membership<'community'>[]) => void,
 ) => {
   const client = getActiveClient();
 
@@ -82,13 +83,18 @@ export const createCommunityMemberEventSubscriber = (
         preparedPayload.communities[0].communityId,
       ])!;
 
-      const member = pullFromCache<Amity.Membership<'community'>>([
-        'communityUsers',
-        'get',
-        getResolver('communityUsers')(getEventRelatedMember(event, preparedPayload)),
-      ])!;
-
-      callback(community.data, member.data);
+      const members = getEventRelatedMember(event, preparedPayload)
+        .map(member => {
+          const memberCache = pullFromCache<Amity.Membership<'community'>>([
+            'communityUsers',
+            'get',
+            getResolver('communityUsers')(member),
+          ]);
+          return memberCache?.data;
+        })
+        .filter(isNonNullable);
+
+      callback(community.data, members);
     }
   };