@amityco/ts-sdk 7.7.0 → 7.7.1-99f7166.0

package/src/@types/domains/stream.ts

@@ -73,6 +73,12 @@ declare global {
        */
       targetId?: string; // communityId, userId, etc..
       targetType?: string; // 'community', 'user', etc..
+      /*
+       * when stream linked with a post and a live channel.
+       */
+      postId?: string;
+      channelId?: string;
+      channelEnabled?: boolean;
     } & Amity.Metadata &
       Amity.Timestamps &
       Amity.SoftDelete;
@@ -81,9 +87,14 @@ declare global {
 
     type StreamLinkedObject = {
       moderation?: Amity.StreamModeration;
+      post?: Amity.InternalPost;
+      getLiveChat: () => Promise<Amity.Channel<'live'> | undefined>;
     };
 
-    type Stream = Amity.InternalStream & Amity.StreamLinkedObject;
+    type Stream = Omit<Amity.InternalStream & Amity.StreamLinkedObject, 'watcherUrl'> & {
+      isBanned: boolean;
+      watcherUrl: null;
+    };
 
     type QueryStreams = {
       isLive?: boolean;

package/src/@types/index.ts

@@ -43,3 +43,4 @@ export * from './domains/invitation';
 export * from './domains/joinRequest';
 export * from './domains/pin';
 export * from './domains/pinnedPost';
+export * from './domains/liveReaction';

package/src/channelRepository/api/createChannel.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import { prepareChannelPayload } from '../utils';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+import { prepareChannelPayload } from '../utils/prepareChannelPayload';
+import { constructChannelObject } from '../utils/constructChannelObject';
 
 /* begin_public_function
   id: channel.create
@@ -23,11 +23,14 @@ import { constructChannelDynamicValue } from '../utils/constructChannelDynamicVa
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: { type: T; userIds?: Amity.InternalUser['userId'][] } & Pick<
-    Amity.Channel<T>,
-    'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'
-  >,
-): Promise<Amity.Cached<Amity.InternalChannel>> => {
+  bundle: {
+    type: T;
+    userIds?: Amity.InternalUser['userId'][];
+    // For live channel linked with a livestream post
+    videoStreamId?: string;
+    postId?: string;
+  } & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'>,
+): Promise<Amity.Cached<Amity.Channel<T>>> => {
   const client = getActiveClient();
   client.log('user/createChannel', bundle);
 
@@ -53,7 +56,7 @@ export const createChannel = async <T extends Amity.ChannelType>(
 
   const { channels } = data;
   return {
-    data: constructChannelDynamicValue(channels[0]),
+    data: constructChannelObject(channels[0]),
     cachedAt,
   };
 };

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -24,6 +24,7 @@ import {
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
 import { LinkedObject } from '~/utils/linkedObject';
+import { onChannelSetUserMuted } from '~/channelRepository/events/onChannelSetUserMuted';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -89,6 +90,7 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
       { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
       { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+      { fn: onChannelSetUserMuted, action: 'onChannelSetUserMuted' },
       { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
     ]);
   }

package/src/channelRepository/events/index.ts

@@ -4,7 +4,7 @@ export * from './onChannelDeleted';
 
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onChannelMuted';
+export * from './onChannelSetMuted';
 
 export * from './onChannelMemberAdded';
 export * from './onChannelMemberRemoved';

package/src/channelRepository/events/onChannelSetMuted.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+
+type CallbackFn = Amity.Listener<Amity.StaticInternalChannel>;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
+export const onChannelSetMuted = (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payloads: Amity.ChannelSetMutedPayload) => {
+      payloads.forEach(payload => {
+        upsertInCache(['channel', 'get', payload.channelId], {
+          // If muteTimeout > now => user is muted
+          // Otherwise => user is unmuted
+          isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+        });
+      });
+
+      const channel = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        payloads[0].channelId,
+      ])?.data;
+
+      if (channel) {
+        callbacks.forEach(cb => cb(channel));
+      }
+    };
+
+    mainDisposer = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/events/onChannelSetUserMuted.ts

@@ -0,0 +1,67 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { pullFromCache, upsertInCache } from '~/cache/api';
+
+type CallbackFn = (
+  channel: Amity.StaticInternalChannel,
+  member: Amity.Membership<'channel'>,
+) => void;
+const callbacks: CallbackFn[] = [];
+let mainDisposer: (() => void) | null = null;
+
+const dispose = (cb: CallbackFn) => {
+  const index = callbacks.indexOf(cb);
+  if (index > -1) {
+    callbacks.splice(index, 1);
+  }
+  if (callbacks.length === 0) {
+    mainDisposer?.();
+  }
+};
+
+export const onChannelSetUserMuted = (
+  callback: (channel: Amity.StaticInternalChannel, member: Amity.Membership<'channel'>) => void,
+): Amity.Unsubscriber => {
+  if (callbacks.length === 0) {
+    const client = getActiveClient();
+
+    const filter = async (payloads: Amity.ChannelSetUserMutedPayload) => {
+      payloads.forEach(payload => {
+        payload.userIds.forEach(userId =>
+          // If muteTimeout > now => user is muted
+          // Otherwise => user is unmuted
+          upsertInCache(['channelUsers', 'get', `${payload.channelId}#${userId}`], {
+            isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+          }),
+        );
+      });
+
+      const channel = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        payloads[0].channelId,
+      ])?.data;
+
+      const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+        'channelUsers',
+        'get',
+        `${payloads[0].channelId}#${payloads[0].userIds[0]}`,
+      ])?.data;
+
+      if (channel && channelUser) {
+        callbacks.forEach(cb => cb(channel, channelUser));
+      }
+    };
+
+    mainDisposer = createEventSubscriber(
+      client,
+      'onChannelUserMute',
+      'channel.setUserMuted',
+      filter,
+    );
+  }
+
+  callbacks.push(callback);
+  return () => dispose(callback);
+};

package/src/channelRepository/internalApi/getChannel.ts

@@ -9,7 +9,6 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { prepareChannelPayload } from '../utils';
 import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js

package/src/channelRepository/observers/getChannel.ts

@@ -10,7 +10,7 @@ import {
   onChannelMemberBanned,
   onChannelMemberRemoved,
   onChannelMemberUnbanned,
-  onChannelMuted,
+  onChannelSetMuted,
   onChannelUpdated,
 } from '../events';
 import { dropFromCache, pullFromCache } from '~/cache/api';
@@ -104,7 +104,7 @@ export const getChannel = (
       onChannelMemberRemoved,
       onChannelMemberBanned,
       onChannelMemberUnbanned,
-      onChannelMuted,
+      onChannelSetMuted,
       convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
       convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
       convertEventPayload(

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

@@ -11,7 +11,6 @@ import {
   onChannelLeft,
   onChannelMemberAdded,
   onChannelMemberRemoved,
-  onChannelMuted,
   onChannelUpdated,
 } from '~/channelRepository/events';
 import {
@@ -58,6 +57,7 @@ import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFe
 import { onChannelUnreadInfoUpdatedLocal } from '~/marker/events/onChannelUnreadInfoUpdatedLocal';
 import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
 import { onChannelUnreadUpdatedLocal } from '~/channelRepository/events/onChannelUnreadUpdatedLocal';
+import { onChannelSetMuted } from '~/channelRepository/events/onChannelSetMuted';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -313,7 +313,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
       },
       { fn: onChannelDeleted, action: Amity.ChannelActionType.OnDelete },
       { fn: onChannelUpdated, action: Amity.ChannelActionType.OnUpdate },
-      { fn: onChannelMuted, action: Amity.ChannelActionType.OnMute },
+      { fn: onChannelSetMuted, action: Amity.ChannelActionType.OnMute },
       {
         fn: (callback: Amity.Listener<Amity.StaticInternalChannel>) => {
           return onChannelJoined(channel => {

package/src/channelRepository/utils/constructChannelObject.ts

@@ -1,6 +1,6 @@
 import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { constructChannelDynamicValue } from './constructChannelDynamicValue';
-import { LinkedObject } from '~/utils/linkedObject';
+import { channelLinkedObject } from '~/utils/linkedObject/channelLinkedObject';
 
 export const constructChannelObject = (channel: Amity.StaticInternalChannel): Amity.Channel => {
   /**
@@ -10,7 +10,7 @@ export const constructChannelObject = (channel: Amity.StaticInternalChannel): Am
    * 3. [LinkedObject.channel] add markAsRead >> Amity.InternalChannel -> Amity.Channel
    */
 
-  return LinkedObject.channel(
+  return channelLinkedObject(
     constructChannelDynamicValue(getChannelMessagePreviewWithUser(channel)),
   );
 };

package/src/client/api/login.ts

@@ -13,6 +13,7 @@ import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLog
 import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
 import legacyReadReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngineOnLoginHandler';
 import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
+import reactionSyncEngineOnLoginHandler from '~/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -201,6 +202,7 @@ export const login = async (
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
       objectResolverEngineOnLoginHandler(),
+      reactionSyncEngineOnLoginHandler(),
     );
 
     if (client.useLegacyUnreadCount) {

package/src/core/events.ts

@@ -33,6 +33,7 @@ const MQTT_EVENTS = [
   'video-streaming.didTerminate',
 
   // 'user.didGlobalBan' remove due to message event,
+  'liveReaction.created',
 ] as const;
 
 /** @hidden */

package/src/core/subscription.ts

@@ -154,6 +154,16 @@ export const getSmartFeedMessageTopic = (): string => {
   return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
 };
 
+export const getLiveStreamTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/videostreaming`;
+};
+
+export const getLiveReactionTopic = (post: Amity.Post) => {
+  return `${post.path}/liveReaction`;
+};
+
 let mqttAccessToken: string;
 let mqttUserId: string;
 
@@ -168,9 +178,3 @@ export function subscribeTopic(
 
   return mqtt.subscribe(topic, callback);
 }
-
-export const getLiveStreamTopic = (): string => {
-  const user = getActiveUser();
-
-  return `${getNetworkId(user)}/videostreaming`;
-};

package/src/index.ts

@@ -53,3 +53,5 @@ export * from './external/api';
 export * as notificationTray from './notificationTray';
 
 export * as InvitationRepository from './invitationRepository';
+
+export * as LiveReactionRepository from './liveReactionRepository';

package/src/liveReactionRepository/api/createReaction.ts

@@ -0,0 +1,58 @@
+import { fireEvent } from '~/core/events';
+import ReactionSyncEngine from '../service/ReactionSyncEngine';
+
+import { getActiveClient } from '~/client/api/activeClient';
+// TODO: confirm id
+/* begin_public_function
+  id: live_reaction.create
+*/
+/**
+ * ```js
+ * import { acceptInvitation } from '@amityco/ts-sdk'
+ * const isAccepted = await acceptInvitation(invitationId)
+ * ```
+ *
+ *
+ * @param referenceId that is target post's ID linked with a livestream
+ * @param reactionName that is the reaction name
+ * @param streamId stream id
+ * @returns a success boolean if the reaction was added
+ *
+ * @category Live Reaction API
+ * @async
+ */
+export const createReaction = async ({
+  referenceId,
+  referenceType,
+  reactionName,
+  streamId,
+}: Pick<Amity.CreateLiveReactionRequest, 'referenceType' | 'reactionName'> & {
+  referenceId: string;
+  streamId: string;
+}): Promise<boolean> => {
+  const client = getActiveClient();
+
+  client.log('live_reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  const reactionSynceEngine = ReactionSyncEngine.getInstance();
+
+  const reaction = {
+    reactionName,
+    referencePublicId: referenceId,
+    referenceType,
+    streamId,
+    occurredAt: new Date().toISOString(),
+  };
+
+
+  reactionSynceEngine.createLiveReaction(reaction);
+
+  fireEvent('local.liveReaction.created', [{ ...reaction, userId: client.userId!, referenceId }]);
+
+  return true;
+};
+/* end_public_function */

package/src/liveReactionRepository/api/index.ts

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

package/src/liveReactionRepository/events/index.ts

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

package/src/liveReactionRepository/events/onLiveReactionCreated.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+/**
+ * ```js
+ * import { onLiveReactionCreated } from '@amityco/ts-sdk'
+ * const dispose = onLiveReactionCreated(reactions => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a batch of {@link Amity.LiveReaction} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Live Reaction Events
+ */
+export const onLiveReactionCreated = (
+  callback: Amity.Listener<Amity.LiveReaction[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.LiveReactionPayload) => {
+    if (rawPayload.reactions.length > 0) {
+      // TODO: check with BE if user id is internal or pulbic id
+      const filteredPayload = rawPayload.reactions.filter(({ userId }) => userId !== client.userId);
+      callback(filteredPayload);
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'live_reaction/onLiveReactionCreated',
+    'liveReaction.created',
+    filter,
+  );
+};

package/src/liveReactionRepository/events/onLiveReactionCreatedLocal.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+/**
+ * ```js
+ * import { onLiveReactionCreatedLocal } from '@amityco/ts-sdk'
+ * const dispose = onLiveReactionCreatedLocal(reactions => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a batch of {@link Amity.LiveReaction} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Live Reaction Events
+ */
+export const onLiveReactionCreatedLocal = (
+  callback: Amity.Listener<Amity.LiveReaction[]>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(
+    client,
+    'live_reaction/onLiveReactionCreated',
+    'local.liveReaction.created',
+    callback,
+  );
+};

package/src/liveReactionRepository/index.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './events';
+export * from './observers';

package/src/liveReactionRepository/internalApi/createLiveReaction.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api/activeClient';
+// TODO: confirm id
+/* begin_public_function
+  id: live_reaction.create
+*/
+/**
+ * ```js
+ * import { acceptInvitation } from '@amityco/ts-sdk'
+ * const isAccepted = await acceptInvitation(invitationId)
+ * ```
+ *
+ * Accepts array of {@link Amity.LiveReaction} object without userId
+ *
+ * @param reactions the array of {@link Amity.LiveReaction} to create
+//  TODO: confirm what is the ids in addedIds
+ * @returns An object addedIds contains array of reaction ID
+ *
+ * @category Live Reaction API
+ * @async
+ */
+export const createLiveReaction = async ({
+  reactions,
+  liveStreamId,
+}: {
+  reactions: Amity.CreateLiveReactionRequest[];
+  liveStreamId: string;
+}): Promise<Amity.CreateLiveReactionResponse> => {
+  const client = getActiveClient();
+
+  client.log('live_reaction/addReaction', reactions);
+
+  const { data } = await client.http.post<Amity.CreateLiveReactionResponse>(
+    `/api/v1/reactions/live`,
+    {
+      liveStreamId,
+      reactions,
+    },
+  );
+
+  return data;
+};
+/* end_public_function */

package/src/liveReactionRepository/observers/getReactions.ts

@@ -0,0 +1,59 @@
+import { ASCError } from '~/core/errors';
+import { onLiveReactionCreated } from '../events';
+import { getActiveClient, getActiveUser } from '~/client';
+import { onLiveReactionCreatedLocal } from '../events/onLiveReactionCreatedLocal';
+
+/**
+ *
+ * ```js
+ * import { getReactions } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = getReactions(response => {
+ *       reactions = response.data
+ * });
+ * ```
+ *
+ * Observe live reactions {@link_Amity.LiveReaction} that have been created in a post linked with a stream
+ *
+ * @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 events
+ *
+ * @category Live Reaction Observable
+ */
+// TODO: confirm return type for this observable property
+export const getReactions = (
+  postId: string,
+  callback: Amity.Listener<Amity.LiveReaction[]>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`getReactions(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveReaction[]) => {
+    callback(data);
+  };
+
+  const realtimeRouter = (data: Amity.LiveReaction[]) => {
+    const relevantReactions = data.filter(({ referenceId }) => referenceId === postId);
+    dispatcher(relevantReactions);
+  };
+
+  disposers.push(onLiveReactionCreated(realtimeRouter));
+  disposers.push(onLiveReactionCreatedLocal(realtimeRouter));
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/liveReactionRepository/observers/index.ts

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