@amityco/ts-sdk 7.6.1-2841ad2c.0 → 7.6.1-63bd9d56.0

package/src/channelRepository/observers/getMyMembership.ts

@@ -1,98 +0,0 @@
-import { getActiveUser } from '~/client/api/activeUser';
-import { getMyMembership as _getMyMembership } from '../internalApi/getMyMembership';
-import { ASCApiError, ASCError } from '~/core/errors';
-import { getActiveClient } from '~/client/api/activeClient';
-import { isEqual } from '~/utils/isEqual';
-import { createQuery, runQuery } from '~/core/query';
-import {
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_VALUE,
-} from '~/utils/constants';
-import { channelMemberLinkedObject } from '~/utils/linkedObject/channelMemberLinkedObject';
-import { onChannelMemberBanned, onChannelMemberUnbanned } from '../events';
-import { onChannelSetUserMuted } from '../events/onChannelSetUserMuted';
-
-export const getMyMembership = (
-  channelId: string,
-  callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>,
-): 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, cache } = getActiveClient();
-
-  if (!cache) {
-    console.log('This observable object need the cache data!');
-  }
-
-  const timestamp = Date.now();
-  log(`liveMymembership(tmpid: ${timestamp}) > listen`);
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  let isUnsyncedModel = false; // for messages
-
-  let model: Amity.Membership<'channel'> | undefined;
-
-  const dispatcher = (data: Amity.LiveObject<Amity.Membership<'channel'> | undefined>) => {
-    callback({
-      ...data,
-      data: data.data ? channelMemberLinkedObject(data.data) : data.data,
-    });
-  };
-
-  const realtimeRouter = (_: Amity.StaticInternalChannel, __: Amity.RawMembership<'channel'>) => {
-    const { data } = _getMyMembership(channelId);
-
-    if (isEqual(model, data)) return;
-
-    dispatcher({
-      loading: false,
-      data,
-    });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(async () => _getMyMembership(channelId));
-
-    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
-      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-        dispatcher({
-          data,
-          origin,
-          loading: false,
-          error: new ASCApiError(
-            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
-            Amity.ErrorLevel.ERROR,
-          ),
-        });
-
-        isUnsyncedModel = true;
-        disposers.forEach(fn => fn());
-      } else if (!isUnsyncedModel) {
-        dispatcher({ loading, data, origin, error });
-      }
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(onChannelMemberBanned(realtimeRouter));
-  disposers.push(onChannelMemberUnbanned(realtimeRouter));
-  disposers.push(onChannelSetUserMuted(realtimeRouter));
-
-  onFetch();
-
-  return () => {
-    disposers.forEach(fn => fn());
-  };
-};

package/src/feedRepository/api/getCustomRankingGlobalFeed.ts

@@ -1,115 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { getResolver } from '~/core/model';
-import { prepareMembershipPayload } from '~/group/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: feed.query.custom_ranking_feed
-*/
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-export const getCustomRankingGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
-  limit?: number;
-  queryToken?: string;
-}): Promise<
-  Omit<Amity.Cached<Amity.Paged<Amity.Post>> & Amity.Pagination, 'nextPage' | 'prevPage'>
-> => {
-  const client = getActiveClient();
-  client.log('feed/getCustomRankingGlobalFeed', query);
-
-  const { queryToken, limit, ...params } = query ?? {};
-
-  const options = (() => {
-    if (queryToken) return { token: queryToken };
-    return undefined;
-  })();
-
-  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    `/api/v5/me/global-feeds`,
-    {
-      params: {
-        ...params,
-        limit: !queryToken ? limit : undefined,
-        options,
-      },
-    },
-  );
-
-  const { paging, ...payload } = queryPayload;
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-
-  const { posts } = data;
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) {
-    ingestInCache(data);
-
-    const cacheKey = ['customGlobalFeed', 'query', { ...params, options } as Amity.Serializable];
-    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
-  }
-
-  return { data: posts.map(LinkedObject.post), cachedAt, paging };
-};
-/* end_public_function */
-
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed.locally()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects from cache
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-getCustomRankingGlobalFeed.locally = (
-  query?: Parameters<typeof getCustomRankingGlobalFeed>[0],
-):
-  | Omit<Amity.Cached<Amity.Paged<Amity.Post>> & Amity.Pagination, 'nextPage' | 'prevPage'>
-  | undefined => {
-  const client = getActiveClient();
-  client.log('post/getCustomRankingGlobalFeed.locally', query);
-
-  if (!client.cache) return;
-
-  const { ...params } = query ?? {};
-
-  const queryKey = ['customGlobalFeed', 'query', { ...params } as Amity.Serializable];
-
-  const { data, cachedAt } =
-    pullFromCache<{ posts: Amity.Post['postId'][] } & Amity.Pagination>(queryKey) ?? {};
-
-  if (!data?.posts.length) return;
-
-  const posts: Amity.InternalPost[] = data.posts
-    .map(postId => pullFromCache<Amity.InternalPost>(['post', 'get', postId])!)
-    .filter(Boolean)
-    .map(({ data }) => data);
-
-  const { paging } = data;
-
-  return posts.length === data?.posts?.length
-    ? { data: posts.map(LinkedObject.post), cachedAt, paging }
-    : undefined;
-};

package/src/liveReactionRepository/api/createReaction.ts

@@ -1,58 +0,0 @@
-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

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

package/src/liveReactionRepository/events/index.ts

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

package/src/liveReactionRepository/events/onLiveReactionCreated.ts

@@ -1,37 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

package/src/liveReactionRepository/internalApi/createLiveReaction.ts

@@ -1,42 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

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

package/src/liveReactionRepository/service/ReactionSyncEngine.ts

@@ -1,138 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/streamRepository/api/editStream.ts

@@ -1,51 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: stream.update
-*/
-/**
- *
- * ```js
- * import { StreamRepository } from '@amityco/ts-sdk'
- * const updated = await StreamRepository.editStream(streamId, { title: 'foobar' })
- * ```
- *
- * Updates an {@link Amity.Stream}
- *
- * @param streamId The ID of the {@link Amity.Stream} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Stream} object
- *
- * @category Stream API
- * @async
- */
-
-export const editStream = async (
-  streamId: Amity.Stream['streamId'],
-  patch: Patch<
-    Amity.Stream,
-    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
-  >,
-): Promise<Amity.Cached<Amity.Stream>> => {
-  const client = getActiveClient();
-  client.log('stream/updateStream', streamId, patch);
-
-  const { data } = await client.http.put<Amity.StreamPayload>(
-    `/api/v3/video-streaming/${streamId}`,
-    patch,
-  );
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { videoStreamings } = data;
-
-  return {
-    data: LinkedObject.stream(videoStreamings.find(stream => stream.streamId === streamId)!),
-    cachedAt,
-  };
-};
-/* end_public_function */