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

package/src/userRepository/utils/convertRawUserToInternalUser.ts

@@ -0,0 +1,6 @@
+export function convertRawUserToInternalUser(rawUser: Amity.RawUser): Amity.InternalUser {
+  return {
+    ...rawUser,
+    isGlobalBanned: rawUser?.isGlobalBan || false,
+  };
+}

package/src/userRepository/utils/prepareBlockedUserPayload.ts

@@ -0,0 +1,19 @@
+import { convertRawUserToInternalUser } from './convertRawUserToInternalUser';
+
+export function prepareBlockedUserPayload(
+  response: Amity.BlockedUserPayload,
+): Amity.ProcessedBlockedUserPayload {
+  const { users, follows, ...rest } = response;
+
+  return {
+    ...rest,
+    follows: follows.map(follow => {
+      const followUser = users.find(user => user.userId === follow.from)!;
+      return {
+        ...follow,
+        user: convertRawUserToInternalUser(followUser),
+      };
+    }),
+    users: users.map(convertRawUserToInternalUser),
+  };
+}

package/src/userRepository/utils/prepareUserPayload.ts

@@ -0,0 +1,8 @@
+import { convertRawUserToInternalUser } from './convertRawUserToInternalUser';
+
+export function prepareUserPayload(response: Amity.UserPayload): Amity.ProcessedUserPayload {
+  return {
+    users: response.users.map(convertRawUserToInternalUser),
+    files: response.files,
+  };
+}

package/src/utils/constants.ts

@@ -0,0 +1,16 @@
+export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';
+export const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
+export const LIVE_OBJECT_ENABLE_CACHE_MESSAGE =
+  'For using Live Object feature you need to enable Cache!';
+export const UNSYNCED_OBJECT_CACHED_AT_MESSAGE =
+  'Observing unsynced object is not supported by Live Object.';
+export const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+export const SECOND = 1000;
+export const MINUTE = 60 * SECOND;
+export const HOUR = 60 * MINUTE;
+export const DAY = 24 * HOUR;
+export const WEEK = 7 * DAY;
+export const MONTH = 30 * DAY;
+export const YEAR = 365 * DAY;
+export const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;

package/src/utils/dateTime.ts

@@ -0,0 +1,3 @@
+export const convertDateStringToTimestamp = (dateString: string) => {
+  return new Date(dateString).getTime();
+};

package/src/utils/env.ts

@@ -0,0 +1,12 @@
+/* eslint-disable no-undef */
+const theGlobal =
+  // eslint-disable-next-line no-nested-ternary
+  typeof globalThis === 'object' ? globalThis : typeof global === 'object' ? global : window;
+
+export const { process: safeProcess = {} }: { process: Partial<NodeJS.Process> } = theGlobal;
+
+export function getEnv(): NodeJS.ProcessEnv | undefined {
+  return safeProcess.env ?? {};
+}
+
+export const isProduction = safeProcess.env?.NODE_ENV === 'production';

package/src/utils/event.ts

@@ -0,0 +1,25 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+
+export const convertEventPayload =
+  <
+    SourceModel extends Amity.Model,
+    DestinationDomain extends Amity.Domain,
+    DestinationModel extends Amity.Models[DestinationDomain],
+  >(
+    eventHandler: (callback: Amity.Listener<SourceModel>) => Amity.Unsubscriber,
+    sourceModelProp: keyof SourceModel,
+    destinationDomain: DestinationDomain,
+  ) =>
+  (callback: Amity.Listener<DestinationModel>) =>
+    eventHandler(sourceModel => {
+      if (!sourceModel) {
+        return sourceModel;
+      }
+
+      const cacheKey = [destinationDomain, 'get', `${sourceModel[sourceModelProp]}`];
+      const model = pullFromCache<DestinationModel>(cacheKey)?.data;
+
+      if (!model) return;
+
+      return callback(model);
+    });

package/src/utils/index.ts

@@ -0,0 +1,57 @@
+import { identifyModelKey } from '~/core/model';
+import { isEqual } from '~/utils/isEqual';
+
+export function hasMention(model: Amity.Mentionable<'user' | 'channel'>, userId: string) {
+  const channelMention = model?.mentionees?.find(x => x.type === 'channel') as Amity.ChannelMention;
+
+  if (channelMention) {
+    return true;
+  }
+
+  const userMention = model?.mentionees?.find(x => x.type === 'user') as Amity.UserMention;
+
+  if (userMention) {
+    return userMention.userIds.includes(userId);
+  }
+
+  return false;
+}
+
+export function shouldDispatchCollection<T extends Amity.Models[Amity.Domain] & Amity.UpdatedAt>(
+  collection: T[],
+  newItem: T,
+  action: 'onCreate' | string,
+): boolean {
+  const key = identifyModelKey(newItem);
+  // @ts-ignore
+  const item = collection.find(x => x[key] === newItem[key]);
+
+  if (item) {
+    return !isEqual(item, newItem);
+  }
+
+  return action === 'onCreate';
+}
+
+export function merge<T extends Amity.Models[Amity.Domain]>(
+  collection1: T[],
+  collection2: T[],
+): T[] {
+  const temp = [...collection1, ...collection2];
+
+  if (temp.length === 0) {
+    return [];
+  }
+
+  const key = identifyModelKey(temp[0]);
+  const map = new Map<string, T>();
+
+  // @ts-ignore
+  temp.forEach(x => map.set(x[key], x));
+
+  return Array.from(map.values());
+}
+
+export function isNonNullable<TValue>(value: TValue | undefined | null): value is TValue {
+  return value != null;
+}

package/src/utils/inferIsDeleted.ts

@@ -0,0 +1,16 @@
+/*
+ * This is a simple utility that infers the value of isDeleted based on the
+ * value of includeDeleted
+ *
+ * There are two important things to note here:
+ *  1. `includeDeleted` is purely client side query param and not recognized by
+ *  the server
+ *  2. The only values we wish to expose with regards to `isDeleted` (the server
+ *  param for queries) is false | undefined and want to disallow users to query
+ *  for deleted entities
+ *
+ *  Although this is a very simple utility, it's only purpose is to keep things
+ *  DRY
+ */
+export const inferIsDeleted = (includeDeleted?: boolean): boolean | undefined =>
+  includeDeleted === true ? undefined : false;

package/src/utils/isEqual.ts

@@ -0,0 +1,81 @@
+/**
+ * ```js
+ * import { isEqual } from '~/utils/isEqual'
+ * const isEqual = isEqual(post1, post2)
+ * ```
+ *
+ * Compares two Amity.Model
+ *
+ * @param x the Amity.Model to compare
+ * @param y the Amity.Model to compare wit x
+ * @returns a boolean based on equality
+ *
+ * @category utility
+ * @private
+ */
+export function isEqual(x: any, y: any): boolean {
+  if (x === null || x === undefined || y === null || y === undefined) {
+    return x === y;
+  }
+
+  // after this just checking type of one would be enough
+  if (x.constructor !== y.constructor) {
+    return false;
+  }
+
+  // if they are functions, they should exactly refer to same one (because of closures)
+  if (x instanceof Function) {
+    return x === y;
+  }
+
+  // if they are regexps, they should exactly refer to same one
+  if (x instanceof RegExp) {
+    return x === y;
+  }
+
+  if (x === y || x.valueOf() === y.valueOf()) {
+    return true;
+  }
+
+  if (Array.isArray(x) && x.length !== y.length) {
+    return false;
+  }
+
+  // check each element of the array for equality
+  if (Array.isArray(x) && Array.isArray(y)) {
+    if (x.length !== y.length) return false;
+
+    for (let i = 0; i < x.length; i += 1) {
+      if (!isEqual(x[i], y[i])) return false;
+    }
+
+    // if all elements are equal, the arrays are equal
+    return true;
+  }
+
+  // if they are dates, they must had equal valueOf
+  if (x instanceof Date) {
+    return false;
+  }
+
+  // if they are strictly equal, they both need to be object at least
+  if (!(x instanceof Object)) {
+    return false;
+  }
+
+  if (!(y instanceof Object)) {
+    return false;
+  }
+
+  // recursive object equality check
+  const p = Object.keys(x);
+  return (
+    Object.keys(y).every(i => {
+      // @ts-ignore
+      return p.indexOf(i) !== -1;
+    }) &&
+    p.every(i => {
+      return isEqual(x[i], y[i]);
+    })
+  );
+}

package/src/utils/linkedObject/adLinkedObject.ts

@@ -0,0 +1,50 @@
+import { pullFromCache } from '~/cache/api';
+import AnalyticsEngine from '~/analytic/service/analytic/AnalyticsEngine';
+
+export const adLinkedObject = (ad: Amity.InternalAd): Amity.Ad => {
+  const analyticsEngineInstance = AnalyticsEngine.getInstance();
+  const { image9_16: image916, image1_1: image11, ...restAds } = ad;
+  return {
+    ...restAds,
+    analytics: {
+      markAsSeen: (placement: Amity.AdPlacement) => {
+        analyticsEngineInstance.markAdAsViewed(ad, placement);
+      },
+      markLinkAsClicked: (placement: Amity.AdPlacement) => {
+        analyticsEngineInstance.markAdAsClicked(ad, placement);
+      },
+    },
+    get advertiser(): Amity.Advertiser | undefined {
+      const advertiserData = pullFromCache<Amity.RawAdvertiser>([
+        'advertiser',
+        'get',
+        ad.advertiserId,
+      ])?.data;
+
+      if (!advertiserData) return;
+
+      const avatarFile = pullFromCache<Amity.File<'image'>>([
+        'file',
+        'get',
+        advertiserData.avatarFileId,
+      ])?.data;
+
+      return {
+        ...advertiserData,
+        avatar: avatarFile,
+      };
+    },
+
+    get image1_1(): Amity.File<'image'> | undefined {
+      const cacheData = pullFromCache<Amity.File<'image'>>(['file', 'get', image11]);
+      if (!cacheData) return undefined;
+      return cacheData.data || undefined;
+    },
+
+    get image9_16(): Amity.File<'image'> | undefined {
+      const cacheData = pullFromCache<Amity.File<'image'>>(['file', 'get', image916]);
+      if (!cacheData) return undefined;
+      return cacheData.data || undefined;
+    },
+  };
+};

package/src/utils/linkedObject/categoryLinkedObject.ts

@@ -0,0 +1,18 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+
+export const categoryLinkedObject = (category: Amity.InternalCategory): Amity.Category => {
+  return {
+    ...category,
+    get avatar(): Amity.File<'image'> | undefined {
+      if (!category.avatarFileId) return undefined;
+
+      const avatar = pullFromCache<Amity.File<'image'>>([
+        'file',
+        'get',
+        `${category.avatarFileId}`,
+      ])?.data;
+
+      return avatar;
+    },
+  };
+};

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -0,0 +1,32 @@
+import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
+import { shallowClone } from '../shallowClone';
+import { queryCache } from '~/cache/api';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
+import { getMyMembership } from '~/channelRepository/observers/getMyMembership';
+
+export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
+  let previewMembers: Amity.Membership<'channel'>[] = [];
+
+  if (['conversation', 'community'].includes(channel.type)) {
+    const channelUsers = queryCache<Amity.Membership<'channel'>>(['channelUsers', 'get']);
+    if (channelUsers && channelUsers?.length > 0) {
+      previewMembers = (
+        channelUsers?.filter(
+          ({ data }) => data.channelId === channel.channelId && data.membership !== 'none',
+        ) ?? []
+      )
+        // sort in ascending order by userInternalId
+        .sort((a, b) => a.data.userInternalId.localeCompare(b.data.userInternalId))
+        // Select only first 4 members
+        .slice(0, 4)
+        .map(({ data }) => channelMemberLinkedObject(data));
+    }
+  }
+
+  return shallowClone(channel, {
+    markAsRead: () => markAsRead(channel.channelInternalId),
+    previewMembers,
+    myMembership: (callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>) =>
+      getMyMembership(channel.channelId, callback),
+  });
+};

package/src/utils/linkedObject/channelMemberLinkedObject.ts

@@ -0,0 +1,20 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { userLinkedObject } from './userLinkedObject';
+
+export const channelMemberLinkedObject = (
+  channelMember: Amity.Membership<'channel'>,
+): Amity.Membership<'channel'> => {
+  const getUser = (): Amity.User | undefined => {
+    const cacheKey = ['user', 'get', channelMember.userId];
+    const internalUser = pullFromCache<Amity.InternalUser>(cacheKey)?.data;
+
+    return internalUser ? userLinkedObject(internalUser) : undefined;
+  };
+
+  return {
+    ...channelMember,
+    get user() {
+      return getUser();
+    },
+  };
+};

package/src/utils/linkedObject/commentLinkedObject.ts

@@ -0,0 +1,66 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { userLinkedObject } from './userLinkedObject';
+import { isNonNullable } from '~/utils';
+
+export const commentLinkedObject = (comment: Amity.InternalComment): Amity.Comment => {
+  return {
+    ...comment,
+    get target(): Amity.CommentTarget {
+      const commentTypes: Amity.CommentTarget = {
+        type: comment.targetType,
+      };
+
+      if (comment.targetType === 'user') {
+        return {
+          ...commentTypes,
+          userId: comment.targetId,
+        };
+      }
+
+      if (commentTypes.type === 'content') {
+        return {
+          ...commentTypes,
+          contentId: comment.targetId,
+        };
+      }
+
+      if (commentTypes.type === 'community') {
+        const cacheData = pullFromCache<Amity.Membership<'community'>>([
+          'communityUsers',
+          'get',
+          `${comment.targetId}#${comment.userId}`,
+        ]);
+
+        return {
+          ...commentTypes,
+          communityId: comment.targetId,
+          creatorMember: cacheData?.data,
+        };
+      }
+
+      return {
+        type: 'unknown',
+      };
+    },
+    get creator(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', comment.userId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get childrenComment(): Amity.Comment[] {
+      return comment.children
+        .map(childCommentId => {
+          const commentCache = pullFromCache<Amity.InternalComment>([
+            'comment',
+            'get',
+            childCommentId,
+          ]);
+
+          if (!commentCache?.data) return;
+          return commentCache?.data;
+        })
+        .filter(isNonNullable)
+        .map(item => commentLinkedObject(item!));
+    },
+  };
+};

package/src/utils/linkedObject/communityLinkedObject.ts

@@ -0,0 +1,68 @@
+import { InvitationTypeEnum } from '~/@types';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getMyJoinRequest } from '~/communityRepository/internalAPI/getMyJoinRequest';
+import { joinRequest } from '~/communityRepository/internalAPI/joinCommunity';
+import { getJoinRequests } from '~/communityRepository/observers/getJoinRequests';
+import { createInvitations } from '~/invitationRepository/internalApi';
+import { getInvitation } from '~/invitationRepository/internalApi/getInvitation';
+import { getInvitations } from '~/invitationRepository/observers/getInvitations';
+import { categoryLinkedObject } from './categoryLinkedObject';
+
+export const communityLinkedObject = (community: Amity.InternalCommunity): Amity.Community => {
+  return {
+    ...community,
+    get categories(): Amity.Category[] {
+      return (community?.categoryIds ?? [])
+        .map(categoryId => {
+          const cacheData = pullFromCache<Amity.Category>(['category', 'get', categoryId]);
+          if (cacheData?.data) return categoryLinkedObject(cacheData.data);
+          return undefined;
+        })
+        .filter(category => !!category);
+    },
+    createInvitations: async (userIds: string[]): Promise<void> => {
+      await createInvitations({
+        type: InvitationTypeEnum.CommunityMemberInvite,
+        targetType: 'community',
+        targetId: community.communityId,
+        userIds,
+      });
+    },
+    getMemberInvitations: (
+      params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
+      callback: Amity.LiveCollectionCallback<Amity.Invitation>,
+    ): Amity.Unsubscriber => {
+      return getInvitations(
+        {
+          ...params,
+          targetId: community.communityId,
+          targetType: 'community',
+          type: InvitationTypeEnum.CommunityMemberInvite,
+        },
+        callback,
+      );
+    },
+    getInvitation: async () => {
+      const { data } = await getInvitation('community', community.communityId);
+      return data;
+    },
+    join: async () => joinRequest(community.communityId),
+
+    getJoinRequests: (
+      params: Omit<Amity.QueryJoinRequest, 'communityId'>,
+      callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
+    ): Amity.Unsubscriber => {
+      return getJoinRequests(
+        {
+          ...params,
+          communityId: community.communityId,
+        },
+        callback,
+      );
+    },
+    getMyJoinRequest: async () => {
+      const { data } = await getMyJoinRequest(community.communityId);
+      return data;
+    },
+  };
+};

package/src/utils/linkedObject/eventLinkObject.ts

@@ -0,0 +1,26 @@
+import { userLinkedObject } from './userLinkedObject';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { communityLinkedObject } from './communityLinkedObject';
+
+export const eventLinkedObject = (event: Amity.InternalEvent): Amity.Event => {
+  return {
+    ...event,
+    get creator() {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', event.userId]);
+      if (!cacheData?.data) return;
+      return userLinkedObject(cacheData.data);
+    },
+    get discussionCommunity() {
+      if (!event.communityId) return;
+      const cacheData = pullFromCache<Amity.Community>(['community', 'get', event.communityId]);
+      if (!cacheData?.data) return;
+      return communityLinkedObject(cacheData.data);
+    },
+    get liveStream() {
+      if (!event.livestreamId) return;
+      const cacheData = pullFromCache<Amity.Stream>(['stream', 'get', event.livestreamId]);
+      if (!cacheData?.data) return;
+      return cacheData.data;
+    },
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -0,0 +1,39 @@
+import { storyLinkedObject } from '~/utils/linkedObject/storyLinkedObject';
+import { streamLinkedObject } from '~/utils/linkedObject/streamLinkedObject';
+import { categoryLinkedObject } from './categoryLinkedObject';
+import { commentLinkedObject } from './commentLinkedObject';
+import { userLinkedObject } from './userLinkedObject';
+import { postLinkedObject } from './postLinkedObject';
+import { messageLinkedObject } from './messageLinkedObject';
+import { storyTargetLinkedObject } from './storyTargetLinkedObject';
+import { reactorLinkedObject } from './reactorLinkedObject';
+import { channelLinkedObject } from './channelLinkedObject';
+import { adLinkedObject } from './adLinkedObject';
+import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
+import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
+import { communityLinkedObject } from './communityLinkedObject';
+import { invitationLinkedObject } from './invitationLinkedObject';
+import { joinRequestLinkedObject } from './joinRequestLinkedObject';
+import { channelMemberLinkedObject } from './channelMemberLinkedObject';
+import { eventLinkedObject } from './eventLinkObject';
+
+export const LinkedObject = {
+  ad: adLinkedObject,
+  comment: commentLinkedObject,
+  post: postLinkedObject,
+  user: userLinkedObject,
+  category: categoryLinkedObject,
+  stream: streamLinkedObject,
+  story: storyLinkedObject,
+  storyTarget: storyTargetLinkedObject,
+  message: messageLinkedObject,
+  reactor: reactorLinkedObject,
+  channel: channelLinkedObject,
+  pinnedPost: pinnedPostLinkedObject,
+  notificationTray: notificationTrayLinkedObject,
+  community: communityLinkedObject,
+  invitation: invitationLinkedObject,
+  joinRequest: joinRequestLinkedObject,
+  channelMember: channelMemberLinkedObject,
+  event: eventLinkedObject,
+};

package/src/utils/linkedObject/invitationLinkedObject.ts

@@ -0,0 +1,37 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
+import { acceptInvitation, rejectInvitation } from '~/invitationRepository/internalApi';
+
+export const invitationLinkedObject = (invitation: Amity.InternalInvitation): Amity.Invitation => {
+  return {
+    ...invitation,
+    get user(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.invitedUserPublicId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get createdBy(): Amity.User | undefined {
+      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.inviterUserPublicId]);
+      if (cacheData?.data) return userLinkedObject(cacheData.data);
+      return undefined;
+    },
+    get target(): Amity.InvitationTarget<Amity.InvitationTargetType> | undefined {
+      if (invitation.targetType === 'community') {
+        const cacheData = pullFromCache<Amity.InternalCommunity>([
+          'community',
+          'get',
+          invitation.targetId,
+        ]);
+        if (cacheData?.data) return cacheData.data;
+        return undefined;
+      }
+      return undefined;
+    },
+    accept: async () => {
+      await acceptInvitation(invitation._id);
+    },
+    reject: async () => {
+      await rejectInvitation(invitation._id);
+    },
+  };
+};

package/src/utils/linkedObject/joinRequestLinkedObject.ts

@@ -0,0 +1,31 @@
+import { pullFromCache } from '~/cache/api';
+import { userLinkedObject } from './userLinkedObject';
+import { approveJoinRequest } from '~/communityRepository/joinRequest/internalAPI/approveJoinRequest';
+import { cancelJoinRequest } from '~/communityRepository/joinRequest/internalAPI/cancelJoinRequest';
+import { rejectJoinRequest } from '~/communityRepository/joinRequest/internalAPI/rejectJoinRequest';
+
+export const joinRequestLinkedObject = (
+  joinRequest: Amity.InternalJoinRequest,
+): Amity.JoinRequest => {
+  return {
+    ...joinRequest,
+    get user(): Amity.User | undefined {
+      const user = pullFromCache<Amity.InternalUser>([
+        'user',
+        'get',
+        joinRequest.requestorPublicId,
+      ])?.data;
+      if (!user) return undefined;
+      return userLinkedObject(user);
+    },
+    cancel: async () => {
+      await cancelJoinRequest(joinRequest);
+    },
+    approve: async () => {
+      await approveJoinRequest(joinRequest);
+    },
+    reject: async () => {
+      await rejectJoinRequest(joinRequest);
+    },
+  };
+};

package/src/utils/linkedObject/messageLinkedObject.ts

@@ -0,0 +1,24 @@
+import { pullFromCache } from '~/cache/api';
+import { addReactionToMessage } from '~/messageRepository/utils/addReactionToMessage';
+import { getMessageReadCount } from '~/messageRepository/utils/getMessageReadCount';
+import { markReadMessage } from '~/messageRepository/utils/markReadMessage';
+import { removeReactionToMessage } from '~/messageRepository/utils/removeReactionToMessage';
+
+export const messageLinkedObject = (message: Amity.InternalMessage): Amity.Message => {
+  const { creatorPrivateId, ...rest } = message;
+  return {
+    ...rest,
+    get readCount() {
+      return getMessageReadCount(message).readCount;
+    },
+    get deliveredCount() {
+      return getMessageReadCount(message).deliveredCount;
+    },
+    get creator() {
+      return pullFromCache<Amity.InternalUser>(['user', 'get', message.creatorId])?.data;
+    },
+    markRead: () => markReadMessage(message),
+    addReaction: (reactionName: string) => addReactionToMessage(reactionName, message),
+    removeReaction: (reactionName: string) => removeReactionToMessage(reactionName, message),
+  };
+};