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

package/src/comment/api/getComments.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getComments } from '@amityco/ts-sdk'
+ * const comments = await getComments(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Comment} objects
+ *
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ * @async
+ */
+export const getComments = async (
+  commentIds: Amity.Comment['commentId'][],
+): Promise<Amity.Cached<Amity.Comment[]>> => {
+  const client = getActiveClient();
+  client.log('comment/getComments', commentIds);
+
+  const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data } = await client.http.get<Amity.CommentPayload>(`/api/v3/comments/list`, {
+    params: { commentIds: encodedCommentIds },
+  });
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.comments,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getComments } from '@amityco/ts-sdk'
+ * const comments = getComments.locally(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Comment} objects from cache
+ *
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ */
+getComments.locally = (
+  commentIds: Amity.Comment['commentId'][],
+): Amity.Cached<Amity.Comment[]> | undefined => {
+  const client = getActiveClient();
+  client.log('comment/getComments.locally', commentIds);
+
+  if (!client.cache) return;
+
+  const cached = commentIds
+    .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+    .filter(Boolean);
+
+  const comments = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < commentIds.length) return;
+
+  return {
+    data: comments,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/comment/api/index.ts

@@ -0,0 +1,7 @@
+export * from './queryComments';
+export * from './getComments';
+export * from './getComment';
+
+export * from './createComment';
+export * from './updateComment';
+export * from './deleteComment';

package/src/comment/api/queryComments.ts

@@ -0,0 +1,115 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+/**
+ * ```js
+ * import { queryComments } from '@amityco/ts-sdk'
+ * const comments = await queryComments({ referenceType: 'post', referenceId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Comment} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Comment} objects
+ *
+ * @category Comment API
+ * @async
+ */
+export const queryComments = async (
+  query: Amity.QueryComments,
+): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
+  const client = getActiveClient();
+  client.log('comment/queryComments', query);
+
+  const { page = { limit: 10 }, ...params } = query;
+
+  const options = {
+    type: params.sortBy ? 'pagination' : undefined,
+    token: toToken(page, params.sortBy ? 'skiplimit' : 'afterbefore'),
+  };
+  // const filterByParentId = query.parentId !== undefined
+
+  // API-FIX: parameters should be querystring. (1)
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<Amity.CommentPayload>>>(
+  const { data } = await client.http.get<Amity.CommentPayload & Amity.Pagination>(
+    `/api/v3/comments`,
+    {
+      params: {
+        ...params,
+        //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
+        options,
+      },
+    },
+  );
+
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { paging, comments } = unwrapPayload(data)
+  const { paging, ...payload } = data;
+  const { comments } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.CommentPayload, { cachedAt });
+
+    const cacheKey = [
+      'comment',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { comments: comments.map(getResolver('comment')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: comments, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryComments } from '@amityco/ts-sdk'
+ * const comments = queryComments.locally({ referenceType: 'post', referenceId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Comment} objects from cache
+ *
+ * @param query The query parameters
+ * @returns comments
+ *
+ * @category Comment API
+ */
+queryComments.locally = (
+  query: Parameters<typeof queryComments>[0],
+): Amity.Cached<Amity.Paged<Amity.Comment>> | undefined => {
+  const client = getActiveClient();
+  client.log('comment/queryComments.locally', query);
+
+  if (!client.cache) return;
+
+  const { page = { limit: 10 }, ...params } = query;
+
+  const queryKey = ['comment', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ comments: Pick<Amity.Comment, 'commentId'>[] } & Amity.Pagination>(queryKey) ??
+    {};
+
+  if (!data?.comments.length) return;
+
+  const comments: Amity.Comment[] = data.comments
+    .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return comments.length === data?.comments?.length
+    ? { data: comments, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/comment/api/updateComment.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { updateComment } from '@amityco/ts-sdk'
+ * const updated = await updateComment(commentId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Comment}
+ *
+ * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Comment} object
+ *
+ * @category Comment API
+ * @async
+ */
+export const updateComment = async (
+  commentId: Amity.Comment['commentId'],
+  patch: Patch<Amity.Comment, 'data' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Comment>> => {
+  const client = getActiveClient();
+  client.log('user/updateComment', patch);
+
+  const { data } = await client.http.put<Amity.CommentPayload>(
+    `/api/v3/comments/${encodeURIComponent(commentId)}`,
+    patch,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('comment.updated', data);
+
+  const { comments } = data;
+  return {
+    data: comments.find(comment => comment.commentId === commentId)!,
+    cachedAt,
+  };
+};

package/src/comment/events/index.ts

@@ -0,0 +1,9 @@
+export * from './onCommentCreated';
+export * from './onCommentUpdated';
+export * from './onCommentDeleted';
+
+export * from './onCommentFlagged';
+export * from './onCommentUnflagged';
+
+export * from './onCommentReactionAdded';
+export * from './onCommentReactionRemoved';

package/src/comment/events/onCommentCreated.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentCreated = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.created', callback);

package/src/comment/events/onCommentDeleted.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleted(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentDeleted = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.deleted', callback);

package/src/comment/events/onCommentFlagged.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentFlagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentFlagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentFlagged = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.flagged', callback);

package/src/comment/events/onCommentReactionAdded.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentReactionAdded = (
+  callback: Amity.Listener<Amity.Comment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+    if (!client.cache) {
+      callback(payload.comments[0]);
+    } else {
+      preparePayloadForCache('comment.addReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload);
+
+      const comment = pullFromCache<Amity.Comment>([
+        'comment',
+        'get',
+        payload.comments[0].commentId,
+      ])!;
+
+      callback(comment.data);
+    }
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/comment/events/onCommentReactionRemoved.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { preparePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a reaction has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentReactionRemoved = (
+  callback: Amity.Listener<Amity.Comment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reaction }) => {
+    if (!client.cache) {
+      callback(payload.comments[0]);
+    } else {
+      preparePayloadForCache('comment.removeReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reactor, ...commentPayload } = payload;
+
+      ingestInCache(commentPayload as Amity.CommentPayload);
+
+      const comment = pullFromCache<Amity.Comment>([
+        'comment',
+        'get',
+        payload.comments[0].commentId,
+      ])!;
+
+      callback(comment.data);
+    }
+  };
+
+  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};

package/src/comment/events/onCommentUnflagged.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onCommentUnflagged(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Comment}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentUnflagged = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.unflagged', callback);

package/src/comment/events/onCommentUpdated.ts

@@ -0,0 +1,19 @@
+import { createCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommentUpdated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Comment} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentUpdated = (callback: Amity.Listener<Amity.Comment>): Amity.Unsubscriber =>
+  createCommentEventSubscriber('comment.updated', callback);

package/src/comment/events/utils.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const createCommentEventSubscriber = (
+  event: keyof Amity.MqttCommentMessageEvents,
+  callback: Amity.Listener<Amity.Comment>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommentPayload) => {
+    if (!client.cache) {
+      // TODO: here we are missing specific properties here!
+      callback(payload.comments[0]);
+    } else {
+      ingestInCache(payload);
+
+      const comment = pullFromCache<Amity.Comment>([
+        'comment',
+        'get',
+        payload.comments[0].commentId,
+      ])!;
+
+      if (['comment.created'].includes(event)) {
+        const queries = queryCache(['comment', 'query'])
+          // @ts-ignore
+          ?.filter(({ key }) => key[2]?.referenceId === comment.data.referenceId);
+
+        queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
+      }
+
+      callback(comment.data);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/comment/observers/index.ts

@@ -0,0 +1,3 @@
+export * from './observeComments';
+export * from './observeComment';
+export * from './liveComments';

package/src/comment/observers/liveComments.ts

@@ -0,0 +1,172 @@
+/* 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,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+import { queryComments } from '../api';
+
+/**
+ * ```js
+ * import { liveComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = liveComments({
+ *   referenceType: Amity.Comment['referenceType'];
+ *   referenceId: Amity.Comment['referenceId'];
+ * }, response => merge(comments, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} 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 Comments Live Collection
+ */
+export const liveComments = (
+  params: Amity.CommentLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  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(`liveComments(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 = [
+    'comment',
+    'collection',
+    { referenceId: params.referenceType, referenceType: params.referenceId },
+  ];
+
+  const responder = (data: Amity.CommentLiveCollectionCache) => {
+    let comments: Amity.Comment[] =
+      data.data
+        .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    comments = filterByPropEquality(comments, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    comments = comments.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: comments,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (comment: Amity.Comment, action: Amity.CommentActionType) => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    if (
+      params.referenceId !== comment.referenceId ||
+      params.referenceType !== comment.referenceType ||
+      !collection
+    )
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([comment.commentId, ...collection.data])];
+    } else if (action === 'onDelete') {
+      collection.data = collection.data.filter(p => p !== comment.commentId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    const comments = collection?.data ?? [];
+
+    if (comments.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryComments, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage, nextPage }) => {
+        // depend on sortBy value we have two different pagination type
+        const page = queryParams.sortBy ? nextPage : prevPage;
+
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: comments,
+        };
+
+        if (result) {
+          data.data = [...new Set([...comments, ...result.map(getResolver('comment'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommentCreated(comment => realtimeRouter(comment, 'onCreate')),
+    onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')),
+    onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')),
+    onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')),
+    onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};