@amityco/ts-sdk 7.6.1-a0961ea.0 → 7.6.1-b8014723.0

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

@@ -32,7 +32,6 @@ declare global {
       | 'poll'
       | 'json'
       | 'liveStream'
-      | 'clip'
       | string;
 
     type ContentFeedType = ValueOf<typeof ContentFeedType>;
@@ -63,13 +62,6 @@ declare global {
       };
     };
 
-    type ContentDataClip = {
-      thumbnailFileId: Amity.File<'image'>['fileId'];
-      fileId: Amity.File<'clip'>['fileId'];
-      isMuted?: boolean;
-      displayMode?: Amity.ClipDisplayMode;
-    };
-
     type ContentDataPoll = {
       pollId: Amity.Poll['pollId'];
     };
@@ -90,8 +82,6 @@ declare global {
       ? ContentDataPoll
       : T extends 'liveStream'
       ? ContentDataStream
-      : T extends 'clip'
-      ? ContentDataClip
       : T extends 'json'
       ? Record<string, unknown>
       : T extends string

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

@@ -11,9 +11,8 @@ declare global {
     } & Amity.Timestamps;
 
     type QueryGlobalFeed = {
-      dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
+      dataType?: 'video' | 'image' | 'file' | 'liveStream';
       queryToken?: string;
-      resolveParent?: boolean;
     };
   }
 }

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

@@ -2,7 +2,6 @@ export const FileType = Object.freeze({
   FILE: 'file',
   IMAGE: 'image',
   VIDEO: 'video',
-  CLIP: 'clip',
 });
 
 export const VideoResolution = Object.freeze({
@@ -56,16 +55,12 @@ declare global {
 
     type VideoMetadata = Record<string, never>;
 
-    type ClipMetadata = Record<string, never>;
-
     type MetadataFor<T extends FileType> = T extends 'file'
       ? FileMetadata
       : T extends 'image'
       ? ImageMetadata
       : T extends 'video'
       ? VideoMetadata
-      : T extends 'clip'
-      ? ClipMetadata
       : never;
 
     type File<T extends FileType = any> = Amity.FilePayload<T>;

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

@@ -0,0 +1,25 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawLiveReaction = {
+      userId: string; // user's public ID
+      referenceId: string; // post's internal ID
+      referencePublicId: string; // post's public ID
+      referenceType: string; // 'post'
+      reactionName: string; // 'love
+      // date string in ISO format
+      occurredAt: string;
+    };
+
+    type InternalLiveReaction = RawLiveReaction;
+
+    type LiveReaction = InternalLiveReaction;
+
+    type CreateLiveReactionRequest = Omit<RawLiveReaction, 'userId' | 'referenceId' | 'occurredAt'>;
+
+    type CreateLiveReactionResponse = {
+      addedIds: string[];
+    };
+  }
+}

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

@@ -5,7 +5,6 @@ export const PostContentType = Object.freeze({
   VIDEO: 'video',
   LIVESTREAM: 'liveStream',
   POLL: 'poll',
-  CLIP: 'clip',
 });
 
 declare global {
@@ -74,6 +73,7 @@ declare global {
     };
 
     type PostLinkObject = {
+      childrenPosts: Amity.Post[];
       latestComments: (Amity.Comment | null)[];
       creator: Amity.User | undefined;
       analytics: {
@@ -83,13 +83,12 @@ declare global {
       getVideoInfo: () => Amity.File<'video'> | undefined;
       getVideoThumbnailInfo: () => Amity.File<'image'> | undefined;
       getFileInfo: () => Amity.File<'file'> | undefined;
-      getClipInfo: () => Amity.File<'clip'> | undefined;
+      getPollInfo: () => Amity.Poll | undefined;
+      getLivestreamInfo: () => Amity.Stream | undefined;
     };
 
     type Post<T extends PostContentType = any> = Amity.InternalPost<T> & Amity.PostLinkObject;
 
-    type ClipDisplayMode = 'fill' | 'fit';
-
     type QueryPosts = {
       targetId: string;
       targetType: Amity.InternalPost['targetType'];

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/communityRepository/api/getCommunity.ts

@@ -5,6 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
 import { prepareCommunityPayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
 
 /**
  * ```js
@@ -22,6 +23,8 @@ import { prepareCommunityPayload } from '../utils';
  */
 export const getCommunity = async (
   communityId: Amity.Community['communityId'],
+  type?: Amity.JoinRequestType,
+  includeDiscoverablePrivateCommunity?: boolean,
 ): Promise<Amity.Cached<Amity.InternalCommunity>> => {
   const client = getActiveClient();
   client.log('community/getCommunity', communityId);
@@ -29,6 +32,12 @@ export const getCommunity = async (
   // API-FIX: endpoint should not be /list, parameters should be querystring.
   const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
+    {
+      params: {
+        type: 'communityJoinRequest',
+        includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity ?? true,
+      },
+    },
   );
 
   const data = prepareCommunityPayload(payload);

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/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -23,7 +23,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  * */
 export const getCustomRankingGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream' | 'clip')[];
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
   limit?: number;
   queryToken?: string;
 }): Promise<

package/src/feedRepository/api/queryGlobalFeed.ts

@@ -32,7 +32,7 @@ export const queryGlobalFeed = async (
   const client = getActiveClient();
   client.log('feed/queryGlobalFeed', query);
 
-  const { queryToken, dataTypes, resolveParent, ...params } = query ?? {};
+  const { queryToken, ...params } = query ?? {};
 
   const options = (() => {
     if (queryToken) return { token: queryToken };
@@ -44,8 +44,6 @@ export const queryGlobalFeed = async (
     {
       params: {
         ...params,
-        dataTypes,
-        resolveParent: resolveParent ?? true,
         options,
       },
     },

package/src/fileRepository/api/index.ts

@@ -5,4 +5,3 @@ export * from './fileUrlWithSize';
 export * from './uploadVideo';
 export * from './uploadImage';
 export * from './updateAltText';
-export * from './uploadClip';

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,
+  );
+};