@amityco/ts-sdk 6.12.2-d74459e.0 → 6.12.2-e855934.0

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/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);

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

@@ -13,7 +13,7 @@ import { searchUserByDisplayName } from '../searchUserByDisplayName';
 
 const getSnapshot = (params?: Record<string, any>) => {
   return {
-    data: [] as Amity.User[],
+    data: [] as Amity.InternalUser[],
     loading: true,
     error: undefined as any,
     ...params,

package/src/userRepository/relationship/block/api/blockUser.ts

@@ -12,15 +12,17 @@ import { upsertInCache } from '~/cache/api';
  * const blockedUser = await UserRepository.blockUser('userId')
  * ```
  *
- * Blocks a {@link Amity.User}
+ * Blocks a {@link Amity.InternalUser}
  *
- * @param userId The ID of the {@link Amity.User} to block
- * @returns the blocked {@link Amity.User} object
+ * @param userId The ID of the {@link Amity.InternalUser} to block
+ * @returns the blocked {@link Amity.InternalUser} object
  *
  * @category Post API
  * @async
  */
-export const blockUser = async (userId: Amity.User['userId']): Promise<Amity.BlockedPayload> => {
+export const blockUser = async (
+  userId: Amity.InternalUser['userId'],
+): Promise<Amity.BlockedPayload> => {
   const client = getActiveClient();
 
   client.log('user/blockUser', userId);

package/src/userRepository/relationship/block/api/unBlockUser.ts

@@ -12,15 +12,17 @@ import { upsertInCache } from '~/cache/api';
  * const unblockedUser = await UserRepository.blockUser('userId')
  * ```
  *
- * Blocks a {@link Amity.User}
+ * Blocks a {@link Amity.InternalUser}
  *
- * @param userId The ID of the {@link Amity.User} to unblock
- * @returns the unblocked {@link Amity.User} object
+ * @param userId The ID of the {@link Amity.InternalUser} to unblock
+ * @returns the unblocked {@link Amity.InternalUser} object
  *
  * @category Post API
  * @async
  */
-export const unBlockUser = async (userId: Amity.User['userId']): Promise<Amity.BlockedPayload> => {
+export const unBlockUser = async (
+  userId: Amity.InternalUser['userId'],
+): Promise<Amity.BlockedPayload> => {
   const client = getActiveClient();
 
   client.log('user/unBlockUser', userId);

package/src/userRepository/relationship/block/observers/getBlockedUsers.ts

@@ -3,7 +3,7 @@ import { getBlockedUsers as _getBlockedUsers } from '../../../observers/getBlock
 
 export const getBlockedUsers = (
   params: Amity.BlockedUsersLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.User>,
+  callback: Amity.LiveCollectionCallback<Amity.InternalUser>,
   config?: Amity.LiveCollectionConfig,
 ) => {
   console.log(

package/src/userRepository/relationship/follow/api/acceptFollower.ts

@@ -13,13 +13,13 @@ import { fireEvent } from '~/core/events';
  *
  * Accept the follow request
  *
- * @param userId the ID of the {@link Amity.User} follower
+ * @param userId the ID of the {@link Amity.InternalUser} follower
  * @returns A success boolean if the follow request was accepted
  *
  * @category Follow API
  * @async
  */
-export const acceptFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const acceptFollower = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('follow/acceptFollower', userId);
 

package/src/userRepository/relationship/follow/api/acceptMyFollower.ts

@@ -13,13 +13,13 @@ import { fireEvent } from '~/core/events';
  *
  * Accept the follow request
  *
- * @param userId the ID of the {@link Amity.User} follower
+ * @param userId the ID of the {@link Amity.InternalUser} follower
  * @returns A success boolean if the follow request was accepted
  *
  * @category Follow API
  * @async
  */
-export const acceptMyFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const acceptMyFollower = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('follow/acceptMyFollower', userId);
 

package/src/userRepository/relationship/follow/api/declineFollower.ts

@@ -13,13 +13,13 @@ import { fireEvent } from '~/core/events';
  *
  * Decline the follow request or delete the follower
  *
- * @param userId the ID of the {@link Amity.User} follower
+ * @param userId the ID of the {@link Amity.InternalUser} follower
  * @returns A success boolean if the follow request was decline
  *
  * @category Follow API
  * @async
  */
-export const declineFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const declineFollower = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('follow/declineFollower', userId);
 

package/src/userRepository/relationship/follow/api/declineMyFollower.ts

@@ -13,13 +13,13 @@ import { fireEvent } from '~/core/events';
  *
  * Decline the follow request or delete the follower
  *
- * @param userId the ID of the {@link Amity.User} follower
+ * @param userId the ID of the {@link Amity.InternalUser} follower
  * @returns A success boolean if the follow request was decline
  *
  * @category Follow API
  * @async
  */
-export const declineMyFollower = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const declineMyFollower = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('follow/declineMyFollower', userId);
 

package/src/userRepository/relationship/follow/api/follow.ts

@@ -13,14 +13,14 @@ import { fireEvent } from '~/core/events';
  *
  * Follow the user
  *
- * @param userId the ID of the {@link Amity.User}
+ * @param userId the ID of the {@link Amity.InternalUser}
  * @returns the status {@link Amity.FollowStatus}
  *
  * @category Follow API
  * @async
  */
 export const follow = async (
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
 ): Promise<Amity.Cached<Amity.FollowStatus>> => {
   const client = getActiveClient();
   client.log('follow/follow', userId);

package/src/userRepository/relationship/follow/api/getFollowInfo.ts

@@ -9,14 +9,14 @@ import { pullFromCache, pushToCache } from '~/cache/api';
  *
  * Fetches the number of followers, followings, pending requests and the follow status for current user
  *
- * @param userId the ID of the {@link Amity.User}
+ * @param userId the ID of the {@link Amity.InternalUser}
  * @returns the associated {@link Amity.FollowInfo} object
  *
  * @category Follow API
  * @async
  */
 export const getFollowInfo = async (
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
 ): Promise<Amity.Cached<Amity.FollowInfo>> => {
   const client = getActiveClient();
   client.log('follow/getFollowInfo', userId);
@@ -54,13 +54,13 @@ export const getFollowInfo = async (
  *
  * Fetches the number of followers, followings, pending requests and the follow status for current user from cache
  *
- * @param userId the ID of the {@link Amity.User}
+ * @param userId the ID of the {@link Amity.InternalUser}
  * @returns the associated {@link Amity.FollowInfo} object
  *
  * @category Follow API
  */
 getFollowInfo.locally = (
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
 ): Amity.Cached<Amity.FollowInfo> | undefined => {
   const client = getActiveClient();
   client.log('follow/getFollowInfo.locally', userId);

package/src/userRepository/relationship/follow/api/unfollow.ts

@@ -13,13 +13,13 @@ import { fireEvent } from '~/core/events';
  *
  * Cancel the follow request or unfollow the user
  *
- * @param userId the ID of the {@link Amity.User}
- * @returns A success boolean if the user {@link Amity.User} was unfollowed
+ * @param userId the ID of the {@link Amity.InternalUser}
+ * @returns A success boolean if the user {@link Amity.InternalUser} was unfollowed
  *
  * @category Follow API
  * @async
  */
-export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> => {
+export const unfollow = async (userId: Amity.InternalUser['userId']): Promise<boolean> => {
   const client = getActiveClient();
   client.log('follow/unfollow', userId);
 

package/src/userRepository/relationship/follow/api/utils.ts

@@ -7,7 +7,7 @@ import { getResolver } from '~/core/model';
 export const queryFollows = async (
   key: 'followers' | 'following',
   query: {
-    userId: Amity.User['userId'];
+    userId: Amity.InternalUser['userId'];
     status?: Exclude<Amity.FollowStatusType, 'none'>;
     page?: Amity.PageRaw;
   },

package/src/userRepository/relationship/follow/observers/getFollowers.ts

@@ -29,7 +29,7 @@ import { queryFollowers } from '../api/queryFollowers';
  *
  * let followers = []
  * const unsub = getFollowers({
- *   userId: Amity.User['userId'];
+ *   userId: Amity.InternalUser['userId'];
  * }, response => merge(followers, response.data))
  * ```
  *

package/src/userRepository/relationship/follow/observers/getFollowings.ts

@@ -29,7 +29,7 @@ import { queryFollowings } from '../api/queryFollowings';
  *
  * let followings = []
  * const unsub = getFollowings({
- *   userId: Amity.User['userId'];
+ *   userId: Amity.InternalUser['userId'];
  * }, response => merge(followings, response.data))
  * ```
  *

package/src/userRepository/relationship/follow/observers/observeFollowInfo.ts

@@ -20,7 +20,7 @@ import { onFollowInfoUpdated } from '../events';
  * @category Follow Observer
  */
 export const observeFollowInfo = <Events extends ['onFetch', 'onUpdate']>(
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.FollowInfo>, Events>,
   policy: Amity.QueryPolicy = 'cache_then_server',
 ): Amity.Unsubscriber => {

package/src/userRepository/relationship/follow/observers/observeFollowers.ts

@@ -20,7 +20,7 @@ import {
  *
  * Observe all mutations on a list of followers {@link Amity.FollowStatus} for a given user
  *
- * @param userId the ID of the {@link Amity.User}
+ * @param userId the ID of the {@link Amity.InternalUser}
  * @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 messages
  *
@@ -37,7 +37,7 @@ export const observeFollowers = <
     'onDeleted',
   ],
 >(
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
   callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient();

package/src/userRepository/relationship/follow/observers/observeFollowings.ts

@@ -20,7 +20,7 @@ import {
  *
  * Observe all mutations on a list of followings {@link Amity.FollowStatus} for a given user
  *
- * @param userId the ID of the {@link Amity.User}
+ * @param userId the ID of the {@link Amity.InternalUser}
  * @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 messages
  *
@@ -37,7 +37,7 @@ export const observeFollowings = <
     'onDeleted',
   ],
 >(
-  userId: Amity.User['userId'],
+  userId: Amity.InternalUser['userId'],
   callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
 ): Amity.Unsubscriber => {
   const { log } = getActiveClient();

package/src/utils/linkedObject/categoryLinkedObject.ts

@@ -0,0 +1,40 @@
+import { pullFromCache } from '~/cache/api';
+
+export const categoryLinkedObject = (category: Amity.InternalCategory): Amity.Category => {
+  return {
+    ...category,
+    get avatar(): Amity.File<'image'> | null {
+      if (!category.avatarFileId) return null;
+      let avatar: Amity.File<'image'> = {
+        fileId: category.avatarFileId?.toString() ? category.avatarFileId.toString() : '',
+        type: 'image',
+        fileUrl: '',
+        createdAt: '',
+        attributes: {
+          name: '',
+          extension: '',
+          size: '',
+          mimeType: '',
+          metadata: {
+            exif: {},
+            gps: {},
+            width: 0,
+            height: 0,
+            isFull: false,
+          },
+        },
+      };
+      const cacheData = pullFromCache<Amity.File<'image'>>([
+        'file',
+        'get',
+        `${category.avatarFileId}`,
+      ]);
+
+      if (cacheData?.data) {
+        avatar = cacheData?.data;
+      }
+
+      return avatar as Amity.File<'image'>;
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -1,5 +1,9 @@
+import { categoryLinkedObject } from './categoryLinkedObject';
 import { commentLinkedObject } from './commentLinkedObject';
+import { userLinkedObject } from './userLinkedObject';
 
 export const LinkedObject = {
   comment: commentLinkedObject,
+  user: userLinkedObject,
+  category: categoryLinkedObject,
 };

package/src/utils/linkedObject/userLinkedObject.ts

@@ -0,0 +1,36 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+
+export const userLinkedObject = (user: Amity.InternalUser): Amity.InternalUser => {
+  return {
+    ...user,
+    get avatar(): Amity.File<'image'> | null {
+      if (!user.avatarFileId) return null;
+      let avatar: Amity.File<'image'> = {
+        fileId: user.avatarFileId?.toString() ? user.avatarFileId.toString() : '',
+        type: 'image',
+        fileUrl: '',
+        createdAt: '',
+        attributes: {
+          name: '',
+          extension: '',
+          size: '',
+          mimeType: '',
+          metadata: {
+            exif: {},
+            gps: {},
+            width: 0,
+            height: 0,
+            isFull: false,
+          },
+        },
+      };
+      const cacheData = pullFromCache<Amity.File<'image'>>(['file', 'get', `${user.avatarFileId}`]);
+
+      if (cacheData?.data) {
+        avatar = cacheData?.data;
+      }
+
+      return avatar as Amity.File<'image'>;
+    },
+  };
+};

package/src/utils/tests/client.ts

@@ -43,6 +43,7 @@ export const connectClient = async () => {
     },
   });
 
+  // test will fail randomly if we have this
   setTimeout(() => {
     client.ws.io.emit('connect');
     // fixes jest warning of open handles