@amityco/ts-sdk-react-native 6.12.1 → 6.13.0

package/src/userRepository/api/getUserByIds.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: user.get_by_ids
@@ -40,7 +41,7 @@ export const getUserByIds = async (
   fireEvent('user.fetched', data);
 
   return {
-    data: data.users,
+    data: data.users.map(user => LinkedObject.user(user)),
     cachedAt,
   };
 };
@@ -61,17 +62,17 @@ export const getUserByIds = async (
  */
 getUserByIds.locally = (
   userIds: Amity.User['userId'][],
-): Amity.Cached<Amity.User[]> | undefined => {
+): Amity.Cached<Amity.InternalUser[]> | undefined => {
   const client = getActiveClient();
   client.log('user/getUsers.locally', userIds);
 
   if (!client.cache) return;
 
   const cached = userIds
-    .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+    .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
     .filter(Boolean);
 
-  const users = cached.map(({ data }) => data);
+  const users = cached.map(({ data }) => LinkedObject.user(data));
   const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
   if (cached?.length < userIds.length) return;

package/src/userRepository/api/isUserFlaggedByMe.ts

@@ -16,7 +16,7 @@ import { synchronousWSCall } from '~/core/transports';
  * @category Report API
  * @async
  * */
-export const isUserFlaggedByMe = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const isUserFlaggedByMe = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('user/isUserFlaggedByMe', userId);
 

package/src/userRepository/api/queryBlockedUsers.ts

@@ -11,7 +11,7 @@ import { toPageRaw } from '~/core/query';
  * ```
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category Block API
  * @async
@@ -20,7 +20,7 @@ import { toPageRaw } from '~/core/query';
 export const queryBlockedUsers = async (
   query?: Amity.QueryBlockedUser,
 ): Promise<
-  Amity.Cached<Amity.Paged<Amity.User, Amity.PageRaw>> & {
+  Amity.Cached<Amity.Paged<Amity.InternalUser, Amity.PageRaw>> & {
     total: number;
   }
 > => {
@@ -66,18 +66,18 @@ export const queryBlockedUsers = async (
  * const { data: users } = queryBlockedUsers.locally({ page: 'page_token' })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects from cache
+ * Queries a paginable list of {@link Amity.InternalUser} objects from cache
  * Search is performed by displayName such as `.startsWith(search)`
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category Block API
  */
 queryBlockedUsers.locally = (
   query: Parameters<typeof queryBlockedUsers>[0] = {},
 ):
-  | (Amity.Cached<Amity.Paged<Amity.User, Amity.PageRaw>> & {
+  | (Amity.Cached<Amity.Paged<Amity.InternalUser, Amity.PageRaw>> & {
       total: number;
     })
   | undefined => {
@@ -98,11 +98,13 @@ queryBlockedUsers.locally = (
   const cacheKey = ['blockedUsers', 'query', params as Amity.Serializable];
 
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.BlockedUserPaged>(cacheKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.BlockedUserPaged>(
+      cacheKey,
+    ) ?? {};
 
-  const users: Amity.User[] =
+  const users: Amity.InternalUser[] =
     data?.users
-      .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
       .filter(Boolean)
       .map(({ data }) => data) ?? [];
 

package/src/userRepository/api/queryUsers.ts

@@ -6,6 +6,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { fireEvent } from '~/core/events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -13,18 +14,18 @@ import { fireEvent } from '~/core/events';
  * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects
+ * Queries a paginable list of {@link Amity.InternalUser} objects
  * Search is performed by displayName such as `.startsWith(search)`
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category User API
  * @async
  */
 export const queryUsers = async (
   query: Amity.QueryUsers = {},
-): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.InternalUser>>> => {
   const client = getActiveClient();
   client.log('user/queryUsers', query);
 
@@ -70,7 +71,7 @@ export const queryUsers = async (
   const prevPage = toPage(paging.previous);
   const nextPage = toPage(paging.next);
 
-  return { data: users, cachedAt, prevPage, nextPage };
+  return { data: users.map(user => LinkedObject.user(user)), cachedAt, prevPage, nextPage };
 };
 
 /**
@@ -79,17 +80,17 @@ export const queryUsers = async (
  * const { data: users } = queryUsers.locally({ keyword: 'foo' })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects from cache
+ * Queries a paginable list of {@link Amity.InternalUser} objects from cache
  * Search is performed by displayName such as `.startsWith(search)`
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @returns A page of {@link Amity.InternalUser} objects
  *
  * @category User API
  */
 queryUsers.locally = (
   query: Parameters<typeof queryUsers>[0] = {},
-): Amity.Cached<Amity.Paged<Amity.User>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.InternalUser>> | undefined => {
   const client = getActiveClient();
   client.log('user/queryUsers.locally', query);
 
@@ -107,11 +108,12 @@ queryUsers.locally = (
   ];
 
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(cacheKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.Pagination>(cacheKey) ??
+    {};
 
-  const users: Amity.User[] =
+  const users: Amity.InternalUser[] =
     data?.users
-      .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
       .filter(Boolean)
       .map(({ data }) => data) ?? [];
 

package/src/userRepository/api/unflagUser.ts

@@ -18,7 +18,7 @@ import { fireEvent } from '~/core/events';
  * @category User API
  * @async
  * */
-export const unflagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const unflagUser = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('user/unflag', userId);
 

package/src/userRepository/api/updateUser.ts

@@ -12,22 +12,22 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const updated = await updateUser(userId, { displayName: 'foobar' })
  * ```
  *
- * Updates an {@link Amity.User}
+ * Updates an {@link Amity.InternalUser}
  *
- * @param userId The ID of the {@link Amity.User} to update
+ * @param userId The ID of the {@link Amity.InternalUser} to update
  * @param patch The patch data to apply
- * @returns the updated {@link Amity.User} object
+ * @returns the updated {@link Amity.InternalUser} object
  *
  * @category User API
  * @async
  */
 export const updateUser = async (
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
   patch: Patch<
-    Amity.User,
+    Amity.InternalUser,
     'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
   >,
-): Promise<Amity.Cached<Amity.User>> => {
+): Promise<Amity.Cached<Amity.InternalUser>> => {
   const client = getActiveClient();
   client.log('user/updateUser', userId, patch);
 

package/src/userRepository/events/onUserDeleted.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been deleted
+ * Fired when a {@link Amity.InternalUser} has been deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserDeleted = (callback: Amity.Listener<Amity.User>) =>
+export const onUserDeleted = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.deleted', callback);

package/src/userRepository/events/onUserFetched.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been fetched
+ * Fired when a {@link Amity.InternalUser} has been fetched
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserFetched = (callback: Amity.Listener<Amity.User>) =>
+export const onUserFetched = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.fetched', callback);

package/src/userRepository/events/onUserFlagCleared.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when flags have been cleared for a {@link Amity.User}
+ * Fired when flags have been cleared for a {@link Amity.InternalUser}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserFlagCleared = (callback: Amity.Listener<Amity.User>) =>
+export const onUserFlagCleared = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.flagCleared', callback);

package/src/userRepository/events/onUserFlagged.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been flagged
+ * Fired when a {@link Amity.InternalUser} has been flagged
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserFlagged = (callback: Amity.Listener<Amity.User>) =>
+export const onUserFlagged = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.flagged', callback);

package/src/userRepository/events/onUserUnflagged.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a flag has been removed from a {@link Amity.User}
+ * Fired when a flag has been removed from a {@link Amity.InternalUser}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserUnflagged = (callback: Amity.Listener<Amity.User>) =>
+export const onUserUnflagged = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.unflagged', callback);

package/src/userRepository/events/onUserUpdated.ts

@@ -8,12 +8,12 @@ import { createUserEventSubscriber } from './utils';
  * })
  * ```
  *
- * Fired when a {@link Amity.User} has been updated
+ * Fired when a {@link Amity.InternalUser} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category User Events
  */
-export const onUserUpdated = (callback: Amity.Listener<Amity.User>) =>
+export const onUserUpdated = (callback: Amity.Listener<Amity.InternalUser>) =>
   createUserEventSubscriber('user.updated', callback);

package/src/userRepository/events/utils.ts

@@ -5,7 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 export const createUserEventSubscriber = (
   event: keyof Amity.MqttUserEvents,
-  callback: Amity.Listener<Amity.User>,
+  callback: Amity.Listener<Amity.InternalUser>,
 ) => {
   const client = getActiveClient();
 

package/src/userRepository/observers/getBlockedUsers.ts

@@ -10,6 +10,7 @@ import { createQuery, queryOptions, runQuery, toToken } from '~/core/query';
 import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
 import { getResolver } from '~/core/model';
 import { queryBlockedUsers } from '../api/queryBlockedUsers';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /* begin_public_function
   id: user.get_blocked_users
@@ -20,10 +21,10 @@ import { queryBlockedUsers } from '../api/queryBlockedUsers';
  * const unblockedUser = await UserRepository.blockUser('userId')
  * ```
  *
- * Blocks a {@link Amity.User}
+ * Blocks a {@link Amity.InternalUser}
  *
- * @param params The params to get blocked {@link Amity.User}s
- * @param callback to recieve updates on unblocked {@link Amity.User}s
+ * @param params The params to get blocked {@link Amity.InternalUser}s
+ * @param callback to recieve updates on unblocked {@link Amity.InternalUser}s
  * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
  *
  * @category Post API
@@ -31,7 +32,7 @@ import { queryBlockedUsers } from '../api/queryBlockedUsers';
  */
 export const getBlockedUsers = (
   params: Amity.BlockedUsersLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.User>,
+  callback: Amity.LiveCollectionCallback<Amity.InternalUser>,
   config?: Amity.LiveCollectionConfig,
 ): Amity.Unsubscriber => {
   const { log, cache } = getActiveClient();
@@ -52,11 +53,11 @@ export const getBlockedUsers = (
   const cacheKey = ['blockedUsers', 'collection', {}];
 
   const responder = (data: Amity.BlockedUserLiveCollectionCache) => {
-    const users: Amity.User[] =
+    const users: Amity.InternalUser[] =
       data.data
-        .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+        .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => LinkedObject.user(data)) ?? [];
 
     callback({
       onNextPage: onFetch,

package/src/userRepository/observers/getUser.ts

@@ -23,7 +23,7 @@ import { getUser as _getUser } from '../api/getUser';
  * });
  * ```
  *
- * Observe all mutation on a given {@link Amity.User}
+ * Observe all mutation on a given {@link Amity.InternalUser}
  *
  * @param userId the ID of the user to observe
  * @param callback the function to call when new data are available
@@ -32,8 +32,8 @@ import { getUser as _getUser } from '../api/getUser';
  * @category Message Live Object
  */
 export const getUser = (
-  userId: Amity.User['userId'],
-  callback: Amity.LiveObjectCallback<Amity.User>,
+  userId: Amity.InternalUser['userId'],
+  callback: Amity.LiveObjectCallback<Amity.InternalUser>,
 ): Amity.Unsubscriber => {
   return liveObject(userId, callback, 'userId', _getUser, [
     onUserFetched,

package/src/userRepository/observers/getUsers.ts

@@ -28,6 +28,7 @@ import {
   onUserUnflagged,
   onUserUpdated,
 } from '../events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /*
  * Exported for testing
@@ -106,7 +107,7 @@ export const getUsers = (
       data.data
         .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => LinkedObject.user(data)) ?? [];
 
     callback({
       onNextPage: onFetch,
@@ -125,7 +126,6 @@ export const getUsers = (
     if (!collection) return;
 
     collection.data = [...new Set([user.userId, ...collection.data])];
-
     pushToCache(cacheKey, collection);
     responder(collection, true);
   };

package/src/userRepository/observers/getViewedUsers.ts

@@ -0,0 +1,93 @@
+import { getActiveClient } from '~/client';
+import { COLLECTION_DEFAULT_CACHING_POLICY, ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { createQuery, queryOptions, runQuery } from '~/core/query';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { queryReachUser } from '~/analytic/api/queryReachUser';
+
+export const getViewedUsers = (
+  params: Amity.PostViewedUsersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User | undefined>,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+  const cacheKey = ['postViewedUsers', 'collection', { postId: params.postId }];
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getViewedUsers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, postId } = params;
+
+  const responder = (snapshot: {
+    loading?: boolean;
+    params?: { page: { next: Amity.Token; previous?: Amity.Token } };
+    data: Amity.User['userId'][];
+  }) => {
+    let users: (Amity.User | undefined)[] = [];
+
+    if (snapshot?.data) {
+      users =
+        snapshot.data
+          .map((userId: Amity.User['userId']) => pullFromCache<Amity.User>(['user', 'get', userId]))
+          .filter(Boolean)
+          .map(data => data?.data) || [];
+    }
+
+    callback({
+      // eslint-disable-next-line no-use-before-define
+      onNextPage: onFetch,
+      data: users,
+      hasNextPage: !!snapshot.params?.page?.next,
+      loading: snapshot.loading || false,
+    });
+  };
+
+  const onFetch = (initial = false) => {
+    const collection = pullFromCache<Amity.PostViewedUsersLiveCollectionCache>(cacheKey)?.data;
+
+    const users = collection?.data ?? [];
+
+    if (!initial && users.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryReachUser, {
+      postId,
+      limit: queryLimit || 10,
+      token: !initial ? collection?.params.page?.next : undefined,
+    });
+
+    runQuery(
+      query,
+      result => {
+        let userIds =
+          pullFromCache<Amity.PostViewedUsersLiveCollectionCache>(cacheKey)?.data?.data ?? [];
+
+        if (result.data?.users) {
+          userIds = [
+            ...new Set([...userIds, ...result.data.users.map(({ userId }: Amity.User) => userId)]),
+          ];
+        }
+
+        const saveToCache = {
+          loading: result.loading,
+          params: { page: result.data?.paging },
+          data: userIds || [],
+        };
+
+        pushToCache(cacheKey, saveToCache);
+
+        responder(saveToCache);
+      },
+      queryOptions(COLLECTION_DEFAULT_CACHING_POLICY, CACHE_SHORTEN_LIFESPAN),
+    );
+  };
+
+  onFetch(true);
+
+  return () => {
+    log(`getViewedUsers(tmpid: ${timestamp}) > dispose`);
+    dropFromCache(cacheKey);
+  };
+};

package/src/userRepository/observers/index.ts

@@ -3,3 +3,4 @@ export { getUsers } from './getUsers';
 export { observeUser } from './observeUser';
 export { getBlockedUsers } from './getBlockedUsers';
 export { searchUserByDisplayName } from './searchUserByDisplayName';
+export { getViewedUsers } from './getViewedUsers';

package/src/userRepository/observers/observeUser.ts

@@ -10,6 +10,7 @@ import {
   onUserUnflagged,
   onUserFlagCleared,
 } from '../events';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -23,14 +24,14 @@ import {
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the user
  *
- * Observe all mutation on a given {@link Amity.User}
+ * Observe all mutation on a given {@link Amity.InternalUser}
  * @category User Observer
  */
 export const observeUser = <
   Events extends ['onFetch', 'onUpdate', 'onDelete', 'onFlagged', 'onUnflagged', 'onFlagCleared'],
 >(
   userId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.User>, Events>,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.InternalUser>, Events>,
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient();
 
@@ -38,15 +39,17 @@ export const observeUser = <
   log(`observeUser(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.User>, action: Events[number]) => {
+  const router = (result: Amity.Snapshot<Amity.InternalUser>, action: Events[number]) => {
     // filter function
     if (result.data?.userId !== userId) return;
 
-    if (callback instanceof Function) return callback(result);
+    const newResult = { ...result, data: LinkedObject.user(result.data) };
 
-    if (action !== 'onFetch') callback.onEvent?.(action, result);
+    if (callback instanceof Function) return callback(newResult);
 
-    callback[action]?.(result);
+    if (action !== 'onFetch') callback.onEvent?.(action, newResult);
+
+    callback[action]?.(newResult);
   };
 
   const disposers: Amity.Unsubscriber[] = [];

package/src/userRepository/observers/searchUserByDisplayName.ts

@@ -11,7 +11,7 @@ import { getUsers } from './getUsers';
  * const unsub = UserRepository.searchUserByDisplayName({}, response => merge(users, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.User}s
+ * Observe all mutations on a list of {@link Amity.InternalUser}s
  *
  * @param params for searching users
  * @param callback the function to call when new data are available
@@ -22,7 +22,7 @@ import { getUsers } from './getUsers';
  */
 export const searchUserByDisplayName = (
   params: Amity.UserSearchLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.User>,
+  callback: Amity.LiveCollectionCallback<Amity.InternalUser>,
   config?: Amity.LiveCollectionConfig,
 ) => {
   return getUsers({ ...params, filter: 'all' }, callback, config);

package/src/userRepository/observers/tests/getUser.test.ts

@@ -14,7 +14,7 @@ const getSnapshot = () => {
   return {
     loading: true,
     error: undefined as any,
-    data: undefined as undefined | Amity.User,
+    data: undefined as undefined | Amity.InternalUser,
   };
 };
 

package/src/userRepository/observers/tests/getUsers.test.ts

@@ -18,7 +18,7 @@ const { getUsers, applyFilter } = getUsersModule;
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
-    data: [] as Amity.User[],
+    data: [] as Amity.InternalUser[],
     loading: true,
     error: undefined as any,
     ...params,
@@ -127,7 +127,7 @@ describe('getUsers', () => {
     const unflaggedUser = { ...user11, flagCount: 1 };
     const flagClearedUser = { ...user11, flagCount: 0 };
 
-    const cases: [string, keyof Amity.Events, Amity.UserPayload, Amity.User[]][] = [
+    const cases: [string, keyof Amity.Events, Amity.UserPayload, Amity.InternalUser[]][] = [
       [
         'it should update user in collection onUpdate',
         'user.updated',
@@ -198,20 +198,21 @@ describe('getUsers > applyFilter', () => {
     userId: 'test',
     displayName: 'a',
     createdAt: new Date().toISOString(),
-  } as Amity.User;
+  } as Amity.InternalUser;
 
   const u2 = {
     userId: 'searchable',
     displayName: 'b',
     createdAt: getPastDate(),
-  } as Amity.User;
-
-  const filters: [string, Amity.UserLiveCollection, Amity.User[], Amity.User[]][] = [
-    ['it should filter by display name', { displayName: 'a' }, [u1, u2], [u1]],
-    ['it should sort by dispaly name', {}, [u1, u2], [u1, u2]],
-    ['it should sort by last created', { sortBy: 'lastCreated' }, [u1, u2], [u1, u2]],
-    ['it should sort by first created', { sortBy: 'firstCreated' }, [u1, u2], [u2, u1]],
-  ];
+  } as Amity.InternalUser;
+
+  const filters: [string, Amity.UserLiveCollection, Amity.InternalUser[], Amity.InternalUser[]][] =
+    [
+      ['it should filter by display name', { displayName: 'a' }, [u1, u2], [u1]],
+      ['it should sort by dispaly name', {}, [u1, u2], [u1, u2]],
+      ['it should sort by last created', { sortBy: 'lastCreated' }, [u1, u2], [u1, u2]],
+      ['it should sort by first created', { sortBy: 'firstCreated' }, [u1, u2], [u2, u1]],
+    ];
 
   test.each(filters)('%s', (test, param, input, expected) => {
     expect(applyFilter(input, param)).toStrictEqual(expected);