@amityco/ts-sdk 7.6.1-1a687cb5.0 → 7.6.1-316d940a.0

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

@@ -32,7 +32,10 @@ const MQTT_EVENTS = [
   'video-streaming.didFlag',
   'video-streaming.didTerminate',
 
-  // 'user.didGlobalBan' remove due to message event,
+  'video-streaming.viewerDidBan',
+  'video-streaming.viewerDidUnban',
+
+  '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,
+  );
+};

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';

package/src/liveReactionRepository/service/ReactionSyncEngine.ts

@@ -0,0 +1,138 @@
+import { onOffline } from '~/client/utils/onOffline';
+import { onOnline } from '~/client/utils/onOnline';
+import { SECOND } from '~/utils/constants';
+import { createLiveReaction as _createLiveReaction } from '../internalApi/createLiveReaction';
+
+class LiveReactionSyncEngine {
+  private readonly TIMER_INTERVAL_MS = 1 * SECOND;
+
+  private buffer: (Amity.CreateLiveReactionRequest & { streamId: string })[] = [];
+
+  private timer: NodeJS.Timer | undefined;
+
+  private isSyncing = false;
+
+  private connectionListener: (() => void)[] = [];
+
+  private isConnected = true;
+
+  constructor() {
+    this.addConnectionListener();
+  }
+
+  startReactionsSync() {
+    if (!this.timer) {
+      this.timer = setInterval(() => {
+        if (this.isConnected) this.syncLiveReactions();
+      }, this.TIMER_INTERVAL_MS);
+    }
+  }
+
+  stopReactionsSync() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  createLiveReaction(liveReaction: Amity.CreateLiveReactionRequest & { streamId: string }) {
+    this.buffer.push(liveReaction);
+  }
+
+  private addConnectionListener() {
+    if (this.connectionListener.length > 0) return;
+    this.connectionListener.push(
+      onOnline(() => {
+        this.isConnected = true;
+      }),
+    );
+
+    this.connectionListener.push(
+      onOffline(() => {
+        this.isConnected = false;
+      }),
+    );
+  }
+
+  private removeConnectionListener() {
+    if (this.connectionListener.length > 0) {
+      this.connectionListener.forEach(listener => listener());
+      this.connectionListener = [];
+    }
+  }
+
+  private syncLiveReactions() {
+    if (this.isSyncing) {
+      return;
+    }
+
+    this.isSyncing = true;
+
+    const reactions = this.buffer;
+
+    // Clear buffer
+    this.clearBuffer();
+
+    const payloads: Record<string, Amity.CreateLiveReactionRequest[]> = reactions.reduce(
+      (prev: Record<string, Amity.CreateLiveReactionRequest[]>, curr) => {
+        const { streamId, ...rest } = curr;
+        if (!prev[streamId]) {
+          // eslint-disable-next-line no-param-reassign
+          prev[streamId] = [rest];
+        } else prev[streamId].push(rest);
+        return prev;
+      },
+      {} as Record<string, Amity.CreateLiveReactionRequest[]>,
+    );
+
+    // Call server api `POST /api/v1/reactions/live` to sync live reactions
+    Object.entries(payloads).forEach(([streamId, reactions]) => {
+      _createLiveReaction({
+        liveStreamId: streamId,
+        reactions,
+      });
+    });
+
+    // After sending request
+    this.isSyncing = false;
+  }
+
+  private clearBuffer() {
+    this.buffer = [];
+  }
+
+  // Session Management : SessionComponent
+  onSessionEstablished() {
+    this.startReactionsSync();
+    this.addConnectionListener();
+  }
+
+  onSessionDestroyed() {
+    // Stop timer
+    this.stopReactionsSync();
+
+    // Clear buffer
+    this.clearBuffer();
+
+    // Reset state
+    this.isSyncing = false;
+
+    // remove connection listener
+    this.removeConnectionListener();
+  }
+
+  onTokenExpired() {
+    this.stopReactionsSync();
+  }
+}
+
+let instance: LiveReactionSyncEngine;
+
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new LiveReactionSyncEngine();
+    }
+    return instance;
+  },
+};

package/src/liveReactionRepository/utils/ReactionSyncEngineOnLoginHandler.ts

@@ -0,0 +1,19 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import ReactionSyncEngine from '../service/ReactionSyncEngine';
+
+export default () => {
+  const reactionSynceEngine = ReactionSyncEngine.getInstance();
+  reactionSynceEngine.startReactionsSync();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      reactionSynceEngine.onSessionEstablished();
+    } else if (state === Amity.SessionStates.TOKEN_EXPIRED) {
+      reactionSynceEngine.onTokenExpired();
+    } else reactionSynceEngine.onSessionDestroyed();
+  });
+
+  return () => {
+    reactionSynceEngine.onSessionDestroyed();
+  };
+};

package/src/liveStreamPlayer/api/getPlayer.ts

@@ -60,7 +60,7 @@ export const getPlayer = async (parameters: { streamId: string }): Promise<HTMLV
     video.src = recording.mp4.url;
   }
 
-  new EventRegister(video, resolution).registerEvents();
+  new EventRegister(video, resolution, streamId).registerEvents();
 
   return video;
 };

package/src/liveStreamPlayer/utils/eventRegister.ts

@@ -1,5 +1,6 @@
 import uuid from 'react-native-uuid';
 import { getUsageCollector } from '../api/getUsageCollector';
+import { onStreamViewerBanned } from '~/streamRepository/events';
 
 const SECOND = 1000;
 /*
@@ -32,7 +33,9 @@ export class EventRegister {
 
   _observer: MutationObserver;
 
-  constructor(player: HTMLVideoElement, resolution: string) {
+  _SDKUnsubscribers: Amity.Unsubscriber[] = [];
+
+  constructor(player: HTMLVideoElement, resolution: string, streamId: string) {
     this.player = player;
     this.resolution = resolution;
     this._startTime = null;
@@ -53,10 +56,22 @@ export class EventRegister {
         mutation.removedNodes.forEach(node => {
           if (node === player) {
             this._unregisterEvents();
+            this._SDKUnsubscribers.forEach(fn => fn?.());
           }
         });
       });
     });
+
+    this._SDKUnsubscribers.push(
+      onStreamViewerBanned(stream => {
+        // if still has stream.watcherUrl, the current user has not banned.
+        if (stream.watcherUrl) return;
+        this.player.pause();
+        this.player.removeAttribute('src');
+        this.player.load();
+        this.player.remove();
+      }),
+    );
   }
 
   _resetStartTime() {

package/src/messageRepository/api/deleteMessage.ts

@@ -23,6 +23,22 @@ export const deleteMessage = async (
   const client = getActiveClient();
   client.log('message/deleteMessage', messageId);
 
+  if (messageId.includes('LOCAL_')) {
+    const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])?.data;
+    if (!message) throw Error('messageId not found');
+
+    const deletedMessage = {
+      ...message,
+      isDeleted: true,
+    };
+
+    fireEvent('local.message.deleted', {
+      messages: [deletedMessage],
+    });
+
+    return LinkedObject.message(deletedMessage);
+  }
+
   // API-FIX: This endpoint has not been implemented yet.
   const { data: deleted } = await client.http.delete<Amity.MessagePayload>(
     `/api/v5/messages/${encodeURIComponent(messageId)}`,

package/src/messageRepository/observers/getMessage.ts

@@ -11,6 +11,7 @@ import {
   onMessageReactionAdded,
   onMessageReactionRemoved,
 } from '../events';
+import { onStreamViewerBanned } from '~/streamRepository/events/onStreamViewerBanned';
 import { onMessageFetched } from '../events/onMessageFetched';
 import { LinkedObject } from '~/utils/linkedObject';
 
@@ -57,6 +58,7 @@ export const getMessage = (
     onMessageReactionRemoved,
     convertEventPayload(onMessageMarkerFetched, 'contentId', 'message'),
     convertEventPayload(onMessageMarked, 'contentId', 'message'),
+    convertEventPayload(onStreamViewerBanned, 'channelId', 'message'),
   ]);
 };
 /* end_public_function */

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -11,6 +11,7 @@ import {
   onMessageUnflagged,
   onMessageUpdated,
 } from '~/messageRepository/events';
+import { onStreamViewerBanned } from '~/streamRepository/events/onStreamViewerBanned';
 import { convertEventPayload } from '~/utils/event';
 import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
 import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
@@ -70,6 +71,7 @@ export class MessageLiveCollectionController extends LiveCollectionController<
         action: 'onUpdate',
       },
       { fn: convertEventPayload(onMessageMarked, 'contentId', 'message'), action: 'onUpdate' },
+      { fn: convertEventPayload(onStreamViewerBanned, 'channelId', 'message'), action: 'onUpdate' },
     ]);
   }
 

package/src/messageRepository/observers/getMessages/MessageQueryStreamController.ts

@@ -116,6 +116,19 @@ export class MessageQueryStreamController extends QueryStreamController<
         pushToCache(this.cacheKey, collection);
       }
 
+      if (action === 'onDelete' && payload.syncState === Amity.SyncState.Error) {
+        const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+        if (!collection) return;
+
+        if (collection.data.includes(payload.messageId)) {
+          const newCollectionData = collection.data.filter(
+            messageId => messageId !== payload.messageId,
+          );
+
+          pushToCache(this.cacheKey, { ...collection, data: newCollectionData });
+        }
+      }
+
       this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
     };
   }

package/src/postRepository/api/createPost.ts

@@ -2,8 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
 import { LinkedObject } from '~/utils/linkedObject';
+import { preparePostPayload } from '../utils/payload';
 
 /* begin_public_function
   id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
@@ -46,7 +46,8 @@ export const createPost = async <T extends Amity.PostContentType | string>(
 
   fireEvent('post.created', payload);
 
-  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const data = preparePostPayload(payload);
+
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/postRepository/api/index.ts

@@ -13,5 +13,3 @@ export * from './declinePost';
 export * from './flagPost';
 export * from './unflagPost';
 export * from './isPostFlaggedByMe';
-
-export * from './createClipPost';