@amityco/ts-sdk-react-native 6.20.1 → 6.21.0

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

@@ -76,15 +76,14 @@ export class ChannelQueryStreamController extends QueryStreamController<
         [
           Amity.ChannelActionType.OnCreate,
           Amity.ChannelActionType.OnJoin,
-          Amity.ChannelActionType.OnFetch,
-          Amity.ChannelActionType.OnUserMessageFeedMarkerFetch,
+          Amity.ChannelActionType.OnResolve,
         ].includes(action)
       ) {
-        if (Array.isArray(payload))
+        if (Array.isArray(payload)) {
           collection.data = [
-            ...new Set([...payload.map(({ channelId }) => channelId), ...collection.data]),
+            ...new Set([...payload.map(getResolver('channel')), ...collection.data]),
           ];
-        else collection.data = [...new Set([payload.channelId, ...collection.data])];
+        } else collection.data = [...new Set([payload.channelInternalId, ...collection.data])];
       }
 
       pushToCache(this.cacheKey, collection);

package/src/channelRepository/utils/getChannelIsMentioned.ts

@@ -33,10 +33,10 @@ export const getChannelIsMentioned = (channel: Amity.RawChannel, marker?: Amity.
   const client = getActiveClient();
 
   if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-    return getUnreadInfoCached(channel.channelId)?.isMentioned ?? false;
+    return getUnreadInfoCached(channel.channelPublicId)?.isMentioned ?? false;
   }
 
   return marker?.hasMentioned !== undefined
     ? marker?.hasMentioned
-    : getCachedMarker(channel.channelId)?.hasMentioned ?? false;
+    : getCachedMarker(channel.channelPublicId)?.hasMentioned ?? false;
 };

package/src/channelRepository/utils/getSubChannelsUnreadCount.ts

@@ -36,7 +36,8 @@ export const getSubChannelsUnreadCount = (
   const client = getActiveClient();
 
   if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-    return getUnreadInfoCached(channel.channelId)?.unreadCount ?? 0;
+    // Marker service API uses channelInternalId as channelId
+    return getUnreadInfoCached(channel.channelInternalId)?.unreadCount ?? 0;
   }
 
   if (marker?.isDeleted) {
@@ -46,5 +47,5 @@ export const getSubChannelsUnreadCount = (
     return 0;
   }
 
-  return marker?.unreadCount ?? getCachedMarker(channel.channelId)?.unreadCount ?? 0;
+  return marker?.unreadCount ?? getCachedMarker(channel.channelInternalId)?.unreadCount ?? 0;
 };

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -44,7 +44,7 @@ export function convertFromRaw(
       return getSubChannelsUnreadCount(channel);
     },
     ...channel,
-    defaultSubChannelId: channel._id,
+    defaultSubChannelId: channel.channelInternalId,
     isUnreadCountSupport: isUnreadCountSupport(channel),
     messagePreviewId,
   };
@@ -80,7 +80,7 @@ export const prepareChannelPayload = async (
   const markerIds = rawPayload.channels
     // filter channel by type. Only conversation, community and broadcast type are included.
     .filter(isUnreadCountSupport)
-    .map(({ channelId }) => channelId);
+    .map(({ channelInternalId }) => channelInternalId);
 
   if (markerIds.length > 0) {
     // since the get markers method requires a channel cache to function with the reducer.

package/src/channelRepository/utils/prepateUnreadCountInfo.ts

@@ -6,8 +6,9 @@ export const prepareUnreadCountInfo = async (rawPayload: Amity.ChannelPayload) =
   const client = getActiveClient();
   // if consistent mode is enabled, persist the unread count info to the cache
 
+  // Marker service API uses channelInternalId as channelId
   const queryPayload = await getUserMessageFeedMakers(
-    rawPayload.channels.map(({ channelId }) => channelId),
+    rawPayload.channels.map(({ channelInternalId }) => channelInternalId),
   );
 
   const { feedMarkers, userFeedMarkers } = queryPayload;

package/src/channelRepository/utils/resolveChannels.ts

@@ -0,0 +1,8 @@
+import { getChannelByIds } from '../api/getChannelByIds';
+import { fireEvent } from '~/core/events';
+
+export const resolveChannels = async (channelIds: Amity.InternalChannel['channelPublicId'][]) => {
+  const { data: channels } = await getChannelByIds(channelIds);
+
+  fireEvent('local.channel.resolved', channels);
+};

package/src/client/api/login.ts

@@ -121,9 +121,7 @@ export const login = async (
     // wire websocket events to our event emitter
     proxyWebsocketEvents(client.ws, client.emitter);
 
-    client.ws.once('connect', () => {
-      client.ws.open();
-    });
+    client.ws.open();
 
     client.userId = user.userId;
 

package/src/client/utils/ObjectResolver/objectResolverEngine.ts

@@ -1,9 +1,9 @@
 import { onOnline } from '../onOnline';
-import { getChannelByIds } from '~/channelRepository/api/getChannelByIds';
 
 import { onOffline } from '../onOffline';
-import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
 import { SECOND } from '~/utils/constants';
+import { resolveChannels } from '~/channelRepository/utils/resolveChannels';
+import { resolveUserMessageFeedMarkers } from '~/marker/utils/resolveUserMessageFeedMakers';
 
 class ObjectResolverEngine {
   private readonly TIMER_INTERVAL_MS = SECOND;
@@ -90,8 +90,9 @@ class ObjectResolverEngine {
     // Send Requests.
     // Incase of failure: Ignore
     // Incase of success: Persist in Domain DB & Notify Live collection
-    if (channelIds.length > 0) getChannelByIds(channelIds);
-    if (userMessageFeedMarkerIds.length > 0) getUserMessageFeedMakers(userMessageFeedMarkerIds);
+    if (channelIds.length > 0) resolveChannels(channelIds);
+    if (userMessageFeedMarkerIds.length > 0)
+      resolveUserMessageFeedMarkers(userMessageFeedMarkerIds);
 
     // After sending request
     this.isResolvingTask = false;

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

@@ -4,7 +4,7 @@ export const checkUserPermission = (
   userId: Amity.User['userId'] | undefined,
   permission: string,
 ) => {
-  const user = pullFromCache<Amity.User>(['users', 'get', userId])?.data;
+  const user = pullFromCache<Amity.User>(['user', 'get', userId])?.data;
 
   if (!user) return false;
 

package/src/client/utils/onOffline.ts

@@ -9,6 +9,23 @@ export const onOffline = (callback: () => void) => {
     return () => document.removeEventListener('offline', callback);
   }
 
+  //  @TODO: Please update code below to follow our coding conventions and our TS rules
+  if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    let unsubscribeFn = () => {};
+
+    import('@react-native-community/netinfo').then(NetInfo => {
+      unsubscribeFn = NetInfo.addEventListener(state => {
+        if (state.isConnected) return;
+        callback();
+      });
+    });
+
+    return () => {
+      unsubscribeFn();
+    };
+  }
+
   // Handle unsupported environment
   console.error('Unsupported environment');
   return () => console.error('Unsupported environment');

package/src/commentRepository/events/onCommentReactionAdded.ts

@@ -25,7 +25,7 @@ export const onCommentReactionAdded = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
     if (!client.cache) {
       callback(LinkedObject.comment(payload.comments[0]));
     } else {

package/src/commentRepository/events/onCommentReactionRemoved.ts

@@ -25,7 +25,7 @@ export const onCommentReactionRemoved = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
     if (!client.cache) {
       callback(LinkedObject.comment(payload.comments[0]));
     } else {

package/src/commentRepository/observers/tests/getComment.test.ts

@@ -12,8 +12,8 @@ import {
 } from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
 
-import { getComment } from '../getComment';
 import { LinkedObject } from '~/utils/linkedObject';
+import { getComment } from '../getComment';
 
 describe('getComment', () => {
   const response = {
@@ -81,7 +81,7 @@ describe('getComment', () => {
       data: { text: 'new-text' },
     });
 
-    const reactor: Amity.Reactor = {
+    const reactor: Amity.InternalReactor = {
       createdAt: getFutureDate(update.updatedAt),
       reactionId: 'like',
       reactionName: 'like',

package/src/core/events.ts

@@ -15,6 +15,10 @@ const WS_EVENTS = [
   'sessionStateChange',
   // for internal use by accessTokenExpiryWatcher
   'tokenExpired',
+
+  'v3.video-streaming.didRecord',
+  'v3.video-streaming.didStart',
+  'v3.video-streaming.didStop',
 ] as const;
 
 const MQTT_EVENTS = [

package/src/core/model/idResolvers.ts

@@ -15,7 +15,7 @@ const idResolvers: Resolvers = {
   file: ({ fileId }) => fileId,
   role: ({ roleId }) => roleId,
 
-  channel: ({ channelId }) => channelId,
+  channel: ({ channelInternalId }) => channelInternalId,
   subChannel: ({ subChannelId }) => subChannelId,
   channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
   message: ({ messageId }) => messageId,

package/src/core/query/filtering.ts

@@ -81,7 +81,7 @@ export const filterByChannelMembership = (
 
     // get resolver for the channel by user
     const channelUserCacheKey = getResolver('channelUsers')({
-      channelId: c.channelId,
+      channelId: c.channelPublicId,
       userId,
     });
 

package/src/marker/events/onUserMessageFeedMarkerResolved.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * Internal used only
+ *
+ * Fired when an {@link Amity.userMessageFeedMarkers} has been resolved by Object Rsesolver
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onUserMessageFeedMarkerResolved = (
+  callback: Amity.Listener<Amity.Events['local.userMessageFeedMarkers.resolved']>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.userMessageFeedMarkers.resolved']) => {
+    callback(payload);
+  };
+
+  return createEventSubscriber(
+    client,
+    'userMessageFeedMarker/onUserMessageFeedMarkerResolved',
+    'local.userMessageFeedMarkers.resolved',
+    filter,
+  );
+};

package/src/marker/utils/resolveUserMessageFeedMakers.ts

@@ -0,0 +1,17 @@
+import { getUserMessageFeedMakers } from '../api/getUserMessageFeedMarkers';
+import { fireEvent } from '~/core/events';
+import { persistUnreadCountInfo } from './persistUnreadCountInfo';
+
+export const resolveUserMessageFeedMarkers = async (
+  channelIds: Amity.InternalChannel['channelInternalId'][],
+) => {
+  const queryPayload = await getUserMessageFeedMakers(channelIds);
+
+  const { feedMarkers, userFeedMarkers } = queryPayload;
+  persistUnreadCountInfo({
+    feedMarkers,
+    userFeedMarkers,
+  });
+
+  fireEvent('local.userMessageFeedMarkers.resolved', { feedMarkers, userFeedMarkers });
+};

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -4,15 +4,15 @@ import { getMessageMarkers } from '~/marker/api/getMessageMarkers';
 import { prepareMessagePayloadForCache } from '~/reactionRepository/utils/prepareMessagePayloadForCache';
 import { inferIsDeleted } from '~/utils/inferIsDeleted';
 
-import { getMessageReadCount } from './getMessageReadCount';
 import { MessageContentType } from '~/@types';
 import { convertFromRaw as convertSubChannelFromRaw } from '~/subChannelRepository/utils/convertSubChannelFromRaw';
 import { updateSubChannelCache } from '~/subChannelRepository/utils/updateSubChannelCache';
 import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { getMessageReadCount } from './getMessageReadCount';
 
 export function convertFromRaw(
   message: Amity.RawMessage,
-  reactors?: Amity.Reactor[],
+  reactors?: Amity.InternalReactor[],
   event?: keyof Amity.MqttMessageEvents,
 ): Amity.InternalMessage {
   const {

package/src/postRepository/observers/tests/getPost.test.ts

@@ -76,7 +76,7 @@ describe('getPost', () => {
       data: { text: 'new-text' },
       updatedAt: getFutureDate(post.updatedAt),
     };
-    const reactor: Amity.Reactor = {
+    const reactor: Amity.InternalReactor = {
       createdAt: getFutureDate(post.updatedAt),
       reactionId: 'like',
       reactionName: 'like',

package/src/postRepository/observers/tests/getPosts.test.ts

@@ -214,7 +214,7 @@ describe('getPosts', () => {
   const reactionEvents: [
     string,
     keyof Amity.Events,
-    Amity.PostPayload & { reactor: Amity.Reactor },
+    Amity.PostPayload & { reactor: Amity.InternalReactor },
   ][] = [
     [
       'it should update post in collection onReactionAdded',

package/src/reactionRepository/api/addReaction.ts

@@ -27,7 +27,7 @@ import { dispatchReactable } from '../utils';
 export const addReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reactor['reactionName'],
+  reactionName: Amity.InternalReactor['reactionName'],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('reaction/createReaction', {
@@ -76,7 +76,7 @@ export const addReaction = async (
 addReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reactor['reactionName'],
+  reactionName: Amity.InternalReactor['reactionName'],
 ): boolean | undefined => {
   const client = getActiveClient();
   client.log('reaction/createReaction.optimistically', {

package/src/reactionRepository/api/queryReactor.ts

@@ -11,17 +11,17 @@ import { queryReactions } from './queryReactions';
  * })
  * ```
  *
- * Queries a paginable list of {@link Amity.Reactor} objects
+ * Queries a paginable list of {@link Amity.InternalReactor} objects
  *
  * @param query The query parameters
- * @returns A page of {@link Amity.Reactor} objects
+ * @returns A page of {@link Amity.InternalReactor} objects
  *
  * @reaction Reaction API
  * @async
  * */
 export const queryReactor = async (
   query: Amity.QueryReactions,
-): Promise<Amity.Paged<Amity.Reactor, Amity.Page<string>>> => {
+): Promise<Amity.Paged<Amity.InternalReactor, Amity.Page<string>>> => {
   const client = getActiveClient();
   client.log('reaction/queryReactor', query);
 

package/src/reactionRepository/api/removeReaction.ts

@@ -28,7 +28,7 @@ import { dispatchReactable } from '../utils';
 export const removeReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reactor['reactionName'],
+  reactionName: Amity.InternalReactor['reactionName'],
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('reaction/removeReaction', {
@@ -79,7 +79,7 @@ export const removeReaction = async (
 removeReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reactor['reactionName'],
+  reactionName: Amity.InternalReactor['reactionName'],
 ): boolean | undefined => {
   const client = getActiveClient();
   client.log('reaction/removeReaction.optimistically', {

package/src/reactionRepository/events/onReactorAdded.ts

@@ -11,7 +11,7 @@ import { prepareMessagePayload } from '~/messageRepository/utils';
  * })
  * ```
  *
- * Fired when an {@link Amity.Reactor} has been added
+ * Fired when an {@link Amity.InternalReactor} has been added
  *
  * @param {@link Amity.ReactableType} referenceType
  * @param {string} referenceId
@@ -23,14 +23,14 @@ import { prepareMessagePayload } from '~/messageRepository/utils';
 export const onReactorAdded = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Reactor>,
+  callback: Amity.Listener<Amity.InternalReactor>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const callbackWrapper = (
     referenceType_: Amity.ReactableType,
     referenceId_: Amity.Reaction['referenceId'],
-    reaction: Amity.Reactor,
+    reaction: Amity.InternalReactor,
   ) => {
     if (referenceType_ === referenceType && referenceId_ === referenceId) {
       callback(reaction);
@@ -51,7 +51,7 @@ export const onReactorAdded = (
   }
 
   if (referenceType === 'post') {
-    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.InternalReactor }) => {
       const { reactor, ...rest } = payload;
 
       ingestInCache(rest as Amity.ProcessedPostPayload);
@@ -76,7 +76,7 @@ export const onReactorAdded = (
     return createEventSubscriber(client, 'story.reactionAdded', 'story.reactionAdded', filter);
   }
 
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
     const { reactor, ...rest } = payload;
 
     ingestInCache(rest as Amity.CommentPayload);

package/src/reactionRepository/events/onReactorRemoved.ts

@@ -11,7 +11,7 @@ import { prepareMessagePayload } from '~/messageRepository/utils';
  * })
  * ```
  *
- * Fired when an {@link Amity.Reactor} has been removed
+ * Fired when an {@link Amity.InternalReactor} has been removed
  *
  * @param {@link Amity.ReactableType} referenceType
  * @param {string} referenceId
@@ -23,14 +23,14 @@ import { prepareMessagePayload } from '~/messageRepository/utils';
 export const onReactorRemoved = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Reactor>,
+  callback: Amity.Listener<Amity.InternalReactor>,
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const callbackWrapper = (
     referenceType_: Amity.ReactableType,
     referenceId_: Amity.Reaction['referenceId'],
-    reaction: Amity.Reactor,
+    reaction: Amity.InternalReactor,
   ) => {
     if (referenceType_ === referenceType && referenceId_ === referenceId) {
       callback(reaction);
@@ -51,7 +51,7 @@ export const onReactorRemoved = (
   }
 
   if (referenceType === 'post') {
-    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.InternalReactor }) => {
       const { reactor, ...rest } = payload;
 
       ingestInCache(rest as Amity.ProcessedPostPayload);
@@ -78,7 +78,7 @@ export const onReactorRemoved = (
     return createEventSubscriber(client, 'story.reactionRemoved', 'story.reactionRemoved', filter);
   }
 
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
     const { reactor, ...rest } = payload;
 
     ingestInCache(rest as Amity.CommentPayload);

package/src/reactionRepository/observers/getReactions.ts

@@ -1,14 +1,15 @@
 /* eslint-disable no-use-before-define */
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client/api';
-import { pushToCache, pullFromCache } from '~/cache/api';
-import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { createQuery, queryOptions, runQuery } from '~/core/query';
 
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
 } from '~/utils/constants';
 
+import { LinkedObject } from '~/utils/linkedObject';
 import { onReactorAdded, onReactorRemoved } from '../events';
 import { queryReactor } from '../api/queryReactor';
 
@@ -26,7 +27,7 @@ import { queryReactor } from '../api/queryReactor';
  * }, response => merge(reactions, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Reactor} for a given target object
+ * Observe all mutations on a list of {@link Amity.InternalReactor} for a given target object
  *
  * @param params for querying reactions
  * @param callback the function to call when new data are available
@@ -64,9 +65,9 @@ export const getReactions = (
   const responder = (data: Amity.ReactionLiveCollectionCache) => {
     const reactions: Amity.Reactor[] =
       data.data
-        .map(reactorId => pullFromCache<Amity.Reactor>(['reactor', 'get', reactorId])!)
+        .map(reactorId => pullFromCache<Amity.InternalReactor>(['reactor', 'get', reactorId])!)
         .filter(Boolean)
-        .map(({ data }) => data) ?? [];
+        .map(({ data }) => LinkedObject.reactor(data)) ?? [];
 
     callback({
       onNextPage: onFetch,
@@ -77,19 +78,20 @@ export const getReactions = (
     });
   };
 
-  const realtimeRouter = (action: Amity.ReactionActionType) => (reaction: Amity.Reactor) => {
-    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
+  const realtimeRouter =
+    (action: Amity.ReactionActionType) => (reaction: Amity.InternalReactor) => {
+      const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) return;
 
-    if (action === 'onAdded') {
-      collection.data = [...new Set([reaction.reactionId, ...collection.data])];
-    } else if (action === 'onRemoved') {
-      collection.data = collection.data.filter(p => p !== reaction.reactionId);
-    }
+      if (action === 'onAdded') {
+        collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+      } else if (action === 'onRemoved') {
+        collection.data = collection.data.filter(p => p !== reaction.reactionId);
+      }
 
-    pushToCache(cacheKey, collection);
-    responder(collection);
-  };
+      pushToCache(cacheKey, collection);
+      responder(collection);
+    };
 
   const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;

package/src/reactionRepository/utils/prepareMessagePayloadForCache.ts

@@ -8,7 +8,7 @@ import { getActiveClient } from '~/client/api/activeClient';
  */
 export const prepareMessagePayloadForCache = (
   payload: Amity.InternalMessage,
-  reactors: Amity.Reactor[],
+  reactors: Amity.InternalReactor[],
   event: Pick<Amity.Events, 'message.reactionAdded' | 'message.reactionRemoved'> | string,
 ) => {
   const client = getActiveClient();

package/src/streamRepository/events/onStreamRecorded.ts

@@ -29,7 +29,7 @@ export const onStreamRecorded = (callback: Amity.Listener<Amity.Stream>): Amity.
   return createEventSubscriber(
     client,
     'stream/onStreamRecorded',
-    'video-streaming.didRecord',
+    'v3.video-streaming.didRecord',
     filter,
   );
 };

package/src/streamRepository/events/onStreamStarted.ts

@@ -29,7 +29,7 @@ export const onStreamStarted = (callback: Amity.Listener<Amity.Stream>): Amity.U
   return createEventSubscriber(
     client,
     'stream/onStreamStarted',
-    'video-streaming.didStart',
+    'v3.video-streaming.didStart',
     filter,
   );
 };

package/src/streamRepository/events/onStreamStopped.ts

@@ -26,5 +26,10 @@ export const onStreamStopped = (callback: Amity.Listener<Amity.Stream>): Amity.U
     callback(payload.videoStreamings[0]);
   };
 
-  return createEventSubscriber(client, 'stream/onStreamStarted', 'video-streaming.didStop', filter);
+  return createEventSubscriber(
+    client,
+    'stream/onStreamStropped',
+    'v3.video-streaming.didStop',
+    filter,
+  );
 };

package/src/utils/linkedObject/index.ts

@@ -5,6 +5,7 @@ import { userLinkedObject } from './userLinkedObject';
 import { postLinkedObject } from './postLinkedObject';
 import { messageLinkedObject } from './messageLinkedObject';
 import { storyTargetLinkedObject } from './storyTargetLinkedObject';
+import { reactorLinkedObject } from './reactorLinkedObject';
 
 export const LinkedObject = {
   comment: commentLinkedObject,
@@ -14,4 +15,5 @@ export const LinkedObject = {
   story: storyLinkedObject,
   storyTarget: storyTargetLinkedObject,
   message: messageLinkedObject,
+  reactor: reactorLinkedObject,
 };

package/src/utils/linkedObject/reactorLinkedObject.ts

@@ -0,0 +1,13 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { userLinkedObject } from './userLinkedObject';
+
+export const reactorLinkedObject = (reactor: Amity.InternalReactor): Amity.Reactor => {
+  return {
+    ...reactor,
+    get user(): Amity.User | undefined {
+      const user = pullFromCache<Amity.InternalUser>(['user', 'get', reactor.userId])?.data;
+      if (!user) return undefined;
+      return userLinkedObject(user);
+    },
+  };
+};

package/src/utils/tests/dummy/reaction.ts

@@ -1,6 +1,6 @@
 import { post11, user11 } from '.';
 
-export const reactor11: Amity.Reactor = {
+export const reactor11: Amity.InternalReactor = {
   reactionName: 'reaction11',
   reactionId: 'reaction11',
   userId: user11.userId,