@amityco/ts-sdk 0.0.1-beta → 0.0.1-beta-35

package/src/reaction/observers/liveReactions.ts

@@ -0,0 +1,142 @@
+/* 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 {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import { onReactorAdded, onReactorRemoved } from '../events';
+import { queryReactions } from '../api';
+
+/**
+ * ```js
+ * import { liveReactions } from '@amityco/ts-sdk'
+ *
+ * let reactions = []
+ * const unsub = liveReactions({
+ *   referenceId: Amity.Reaction['referenceId'],
+ *   referenceType: Amity.Reaction['referenceType'],
+ * }, response => merge(reactions, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @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 messages
+ *
+ * @category Reactions Live Collection
+ */
+export const liveReactions = (
+  params: Amity.ReactionLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveReactions(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'reaction',
+    'collection',
+    { referenceId: params.referenceId, referenceType: params.referenceType },
+  ];
+
+  const responder = (data: Amity.ReactionLiveCollectionCache) => {
+    const reactions: Amity.Reactor[] =
+      data.data
+        .map(reactorId => pullFromCache<Amity.Reactor>(['reaction', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: reactions,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (reaction: Amity.Reactor, action: Amity.ReactionActionType) => {
+    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);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+
+    const reactions = collection?.data ?? [];
+
+    if (reactions.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryReactions, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: reactions,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onAdded'),
+    ),
+    onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onRemoved'),
+    ),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/reaction/utils/dispatchReactable.ts

@@ -0,0 +1,17 @@
+import { fireEvent } from '~/core/events';
+
+/** @hidden */
+export const dispatchReactable = <T extends Amity.ReactableType>(
+  referenceType: T,
+  model: Amity.Model[T],
+) => {
+  if (referenceType === 'message')
+    // @ts-ignore: refactor later
+    fireEvent('v3.message.didUpdate', { messages: [model] });
+  else if (referenceType === 'post')
+    // @ts-ignore: refactor later
+    fireEvent('post.updated', { posts: [model] });
+  else if (referenceType === 'comment')
+    // @ts-ignore: refactor later
+    fireEvent('comment.updated', { comments: [model] });
+};

package/src/reaction/utils/fetchReference.ts

@@ -0,0 +1,15 @@
+import { getMessage } from '~/message/api';
+import { getPost } from '~/post/api';
+import { getComment } from '~/comment/api';
+
+/** @hidden */
+export const fetchReference = async (
+  referenceType: Amity.ReactableType,
+  referenceId: string,
+): Promise<Amity.Cached<Amity.Model[typeof referenceType]>> => {
+  if (referenceType === 'message') return getMessage(referenceId);
+  if (referenceType === 'post') return getPost(referenceId);
+  if (referenceType === 'comment') return getComment(referenceId);
+
+  throw new Error(`Incorrect referenceType: ${referenceType}`);
+};

package/src/reaction/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './dispatchReactable';
+export * from './fetchReference';
+export * from './preparePayloadForCache';
+export * from './prepareMessagePayloadForCache';

package/src/reaction/utils/prepareMessagePayloadForCache.ts

@@ -0,0 +1,40 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+export const prepareMessagePayloadForCache = (payload: Amity.Message) => {
+  const client = getActiveClient();
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messageId]);
+  // '[]' in cases where the new reaction is the first one
+  const myReactions = cached?.data.myReactions || [];
+
+  // add myReactions to the payload
+  Object.assign(payload, { myReactions });
+
+  // check if there are any updates to the reactions
+  const latestReaction = payload?.latestReaction;
+  const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+
+  if (!isLatestReactionMine) {
+    return;
+  }
+
+  // new reaction added
+  if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: [...myReactions, latestReaction.reactionName],
+    });
+  }
+
+  // existing reaction removed
+  if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+    });
+  }
+};

package/src/reaction/utils/preparePayloadForCache.ts

@@ -0,0 +1,53 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+export const preparePayloadForCache = <
+  T extends
+    | 'post.addReaction'
+    | 'post.removeReaction'
+    | 'comment.addReaction'
+    | 'comment.removeReaction',
+>(
+  event: T,
+  payload: Amity.Events[T],
+) => {
+  const client = getActiveClient();
+
+  if (client.userId !== payload.reactor.userId) {
+    return;
+  }
+
+  let model: Amity.Reactable;
+  let cached: Amity.Reactable | undefined;
+
+  if (event === 'post.addReaction' || event === 'post.removeReaction') {
+    const post = (payload as Amity.Events['post.addReaction']).posts[0];
+    cached = pullFromCache<Amity.Post>(['post', 'get', post.postId])?.data;
+    model = post;
+  } else {
+    const comment = (payload as Amity.Events['comment.addReaction']).comments[0];
+    cached = pullFromCache<Amity.Comment>(['comment', 'get', comment.commentId])?.data;
+    model = comment;
+  }
+
+  if (!cached || !cached.myReactions) {
+    return;
+  }
+
+  if (event === 'post.addReaction' || event === 'comment.addReaction') {
+    if (cached.myReactions.includes(payload.reactor.reactionName)) {
+      return;
+    }
+
+    Object.assign(model, { myReactions: [...cached.myReactions, payload.reactor.reactionName] });
+  } else {
+    if (!cached.myReactions.includes(payload.reactor.reactionName)) {
+      return;
+    }
+
+    Object.assign(model, {
+      myReactions: cached.myReactions.filter(x => x !== payload.reactor.reactionName),
+    });
+  }
+};

package/src/report/api/createReport.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import REFERENCE_TYPES from '../constants/referenceTypes';
+
+/**
+ * ```js
+ * import { createReport } from '@amityco/ts-sdk'
+ * const flagged = await createReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to add a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new report to.
+ * @returns the created report result
+ *
+ * @category Report API
+ * @async
+ * */
+export const createReport = async (
+  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/createReport', { referenceType, referenceId });
+
+  const { domainName } = REFERENCE_TYPES[referenceType];
+
+  const { data } = await client.http.post<
+    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
+  >(
+    `/api/${
+      referenceType === 'user'
+        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
+        : `v3/${domainName}/${encodeURIComponent(referenceId)}/flag`
+    }`,
+  );
+
+  if (client.cache) ingestInCache(data);
+
+  const event =
+    referenceType === 'message'
+      ? ('v3.message.didUpdate' as const)
+      : (`${referenceType}.flagged` as const);
+
+  fireEvent(event, data);
+
+  return !!data;
+};

package/src/report/api/deleteReport.ts

@@ -0,0 +1,50 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import REFERENCE_TYPES from '../constants/referenceTypes';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { deleteReport } from '@amityco/ts-sdk'
+ * const unflagged = await deleteReport('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to delete a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to delete a report to.
+ * @returns the deleted report result
+ *
+ * @category Report API
+ * @async
+ * */
+export const deleteReport = async (
+  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceId: string,
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('report/deleteReport', { referenceType, referenceId });
+
+  const { domainName } = REFERENCE_TYPES[referenceType];
+
+  const { data } = await client.http.delete<
+    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
+  >(
+    `/api/${
+      referenceType === 'user'
+        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
+        : `v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`
+    }`,
+  );
+
+  if (client.cache) ingestInCache(data);
+
+  const event =
+    referenceType === 'message'
+      ? ('v3.message.didUpdate' as const)
+      : (`${referenceType}.unflagged` as const);
+
+  fireEvent(event, data);
+
+  return !!data;
+};

package/src/report/api/index.ts

@@ -0,0 +1,4 @@
+export * from './createReport';
+export * from './deleteReport';
+
+export * from './isReportedByMe';

package/src/report/api/isReportedByMe.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
+
+import REFERENCE_TYPES from '../constants/referenceTypes';
+
+/**
+ * ```js
+ * import { isReportedByMe } from '@amityco/ts-sdk'
+ * const isReported = await isReportedByMe('post', postId)
+ * ```
+ *
+ * @param referenceType The type of thing to check a report to, such as a post or a comment.
+ * @param referenceId The ID of the thing to check a report to.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ * */
+export const isReportedByMe = async (
+  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceId: string,
+) => {
+  const client = getActiveClient();
+  client.log('report/isReportedByMe', { referenceType, referenceId });
+
+  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
+
+  const { result, isFlagByMe } =
+    (await synchronousWSCall<{
+      result?: boolean;
+      isFlagByMe?: boolean;
+    }>(client, eventName, {
+      [primaryKey]: referenceId,
+    })) ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};

package/src/report/constants/referenceTypes.ts

@@ -0,0 +1,22 @@
+export default {
+  post: {
+    domainName: 'posts',
+    eventName: 'v3/post.isflagbyme',
+    primaryKey: 'postId',
+  },
+  comment: {
+    domainName: 'comments',
+    eventName: 'v3/comment.isflagbyme',
+    primaryKey: 'commentId',
+  },
+  message: {
+    domainName: 'messages',
+    eventName: 'v3/message.isFlaggedByMe',
+    primaryKey: 'messageId',
+  },
+  user: {
+    domainName: 'users',
+    eventName: 'user.isFlagByMe',
+    primaryKey: 'userId',
+  },
+};

package/src/role/api/getRole.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = await getRole('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ * @async
+ */
+export const getRole = async (roleId: Amity.Role['roleId']): Promise<Amity.Cached<Amity.Role>> => {
+  const client = getActiveClient();
+  client.log('role/getRole', roleId);
+
+  const { data } = await client.http.get<Amity.Role[]>(`/api/v3/roles/${roleId}`);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt });
+
+  return {
+    data: data.find(role => role.roleId === roleId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getRole } from '@amityco/ts-sdk'
+ * const role = getRole.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Role} object from cache
+ *
+ * @param roleId the ID of the {@link Amity.Role} to fetch
+ * @returns the associated {@link Amity.Role} object
+ *
+ * @category Role API
+ */
+getRole.locally = (roleId: Amity.Role['roleId']): Amity.Cached<Amity.Role> | undefined => {
+  const client = getActiveClient();
+  client.log('role/getRole.locally', roleId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Role>(['role', 'get', roleId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/role/api/index.ts

@@ -0,0 +1,2 @@
+export { queryRoles } from './queryRoles';
+export { getRole } from './getRole';

package/src/role/api/queryRoles.ts

@@ -0,0 +1,74 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = await queryRoles()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ * @async
+ */
+export const queryRoles = async (query?: {
+  displayName?: Amity.Role['displayName'];
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Role>>> => {
+  const client = getActiveClient();
+  client.log('role/queryRoles', query);
+
+  const { page = { limit: 10 }, displayName, sortBy, ...params } = query ?? {};
+
+  // API-FIX: parameters should be querystring.
+  const { data } = await client.http.get<Amity.RolePayload & Amity.Pagination>(`/api/v3/roles`, {
+    params: {
+      ...params,
+      keyword: displayName,
+      sortBy,
+      options: {
+        token: toToken(page, 'skiplimit'),
+      },
+    },
+  });
+
+  const { paging, ...payload } = data;
+  const { roles } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.RolePayload, { cachedAt });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: roles, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryRoles } from '@amityco/ts-sdk'
+ * const roles = queryRoles.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Role} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Role} objects
+ *
+ * @category Role API
+ */
+queryRoles.locally = (query: Parameters<typeof queryRoles>[0]) => {
+  const client = getActiveClient();
+  client.log('role/queryRoles.locally', query);
+
+  // TODO
+};

package/src/stream/api/createStream.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createStream } from '@amityco/ts-sdk'
+ * const created = await createStream({ title: 'my stream', 'thumbnailFileId': fileId  })
+ * ```
+ *
+ * Creates an {@link Amity.Stream}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Stream}
+ * @returns The newly created {@link Amity.Stream}
+ *
+ * @category Stream API
+ * @async
+ */
+export const createStream = async (
+  bundle: Pick<Amity.Stream, 'title' | 'thumbnailFileId' | 'description'> & { isSecure?: boolean },
+): Promise<Amity.Cached<Amity.Stream>> => {
+  const client = getActiveClient();
+  client.log('stream/createStream', bundle);
+
+  const { data } = await client.http.post<Amity.StreamPayload>('/api/v3/video-streaming', bundle);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { videoStreamings } = data;
+
+  return {
+    data: videoStreamings[0],
+    cachedAt,
+  };
+};

package/src/stream/api/deleteStream.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache } from '~/cache/api';
+
+import { getStream } from './getStream';
+
+// import { unwrapPayload } from '~/core/transports'
+
+/**
+ * ```js
+ * import { deleteStream } from '@amityco/ts-sdk'
+ * const success = await deleteStream(streamId)
+ * ```
+ *
+ * Deletes a {@link Amity.Stream}
+ *
+ * @param streamId The {@link Amity.Stream} ID to delete
+ * @return A success boolean if the {@link Amity.Stream} was deleted
+ *
+ * @category Stream API
+ * @async
+ */
+export const deleteStream = async (streamId: Amity.Stream['streamId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('stream/deleteStream', streamId);
+
+  const stream = await getStream(streamId);
+
+  // API-FIX: it returns { success: boolean } but seems it should be Amity.Response<{ success: boolean }
+  // API-FIX: swagger docs are wrong!
+  const { data } = await client.http.delete<{ success: boolean }>(
+    `/api/v3/video-streaming/${streamId}`,
+  );
+
+  const { success } = data; // unwrapPayload(data)
+  const deleted = { ...stream.data, isDeleted: true };
+
+  upsertInCache(['stream', 'get', streamId], deleted);
+
+  return success;
+};