@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/commentRepository/api/updateComment.ts

@@ -1,50 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: comment.update_comment
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const updated = await CommentRepository.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: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)!),
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/commentRepository/events/index.ts

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

package/src/commentRepository/events/onCommentCreated.ts

@@ -1,20 +0,0 @@
-import { createCommentEventSubscriber } from './utils';
-
-/**
- * ```js
- * import { onCommentCreated } from '@amityco/ts-sdk'
- * const dispose = onCommentCreated(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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.InternalComment>,
-): Amity.Unsubscriber => createCommentEventSubscriber('comment.created', callback);

package/src/commentRepository/events/onCommentCreatedLocal.ts

@@ -1,22 +0,0 @@
-import { createCommentEventSubscriber, createLocalCommentEventSubscriber } from './utils';
-
-/**
- * ```js
- * import { onCommentCreated } from '@amityco/ts-sdk'
- * const dispose = onCommentCreated(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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 onCommentCreatedLocal = (
-  callback: Amity.Listener<Amity.InternalComment>,
-): Amity.Unsubscriber => {
-  return createLocalCommentEventSubscriber('local.comment.created', callback);
-};

package/src/commentRepository/events/onCommentDeleted.ts

@@ -1,20 +0,0 @@
-import { createCommentEventSubscriber } from './utils';
-
-/**
- * ```js
- * import { onCommentDeleted } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleted(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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.InternalComment>,
-): Amity.Unsubscriber => createCommentEventSubscriber('comment.deleted', callback);

package/src/commentRepository/events/onCommentDeletedLocal.ts

@@ -1,20 +0,0 @@
-import { createLocalCommentEventSubscriber } from './utils';
-
-/**
- * ```js
- * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleteLocal(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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 onCommentDeleteLocal = (
-  callback: Amity.Listener<Amity.InternalComment>,
-): Amity.Unsubscriber => createLocalCommentEventSubscriber('local.comment.deleted', callback);

package/src/commentRepository/events/onCommentFlagged.ts

@@ -1,20 +0,0 @@
-import { createCommentEventSubscriber } from './utils';
-
-/**
- * ```js
- * import { onCommentFlagged } from '@amityco/ts-sdk'
- * const dispose = onCommentFlagged(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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.InternalComment>,
-): Amity.Unsubscriber => createCommentEventSubscriber('comment.flagged', callback);

package/src/commentRepository/events/onCommentReactionAdded.ts

@@ -1,48 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { pullFromCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { createEventSubscriber } from '~/core/events';
-import { prepareReactionPayloadFromEvent } from '~/reactionRepository/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/**
- * ```js
- * import { onCommentReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onCommentReactionAdded(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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.InternalComment>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
-    if (!client.cache) {
-      callback(LinkedObject.comment(payload.comments[0]));
-    } else {
-      const processed = prepareReactionPayloadFromEvent('comment.addReaction', payload);
-      const { reactor, ...commentPayload } = processed;
-
-      ingestInCache(commentPayload as Amity.CommentPayload);
-
-      const comment = pullFromCache<Amity.InternalComment>([
-        'comment',
-        'get',
-        payload.comments[0].commentId,
-      ])!;
-
-      callback(LinkedObject.comment(comment.data));
-    }
-  };
-
-  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
-};

package/src/commentRepository/events/onCommentReactionRemoved.ts

@@ -1,49 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { pullFromCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { createEventSubscriber } from '~/core/events';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { prepareReactionPayloadFromEvent } from '~/reactionRepository/utils';
-
-/**
- * ```js
- * import { onCommentReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onCommentReactionRemoved(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a reaction has been removed from a {@link Amity.InternalComment}
- *
- * @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.InternalComment>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.CommentPayload & { reactor: Amity.InternalReactor }) => {
-    if (!client.cache) {
-      callback(LinkedObject.comment(payload.comments[0]));
-    } else {
-      const processed = prepareReactionPayloadFromEvent('comment.removeReaction', payload);
-      const { reactor, ...commentPayload } = processed;
-
-      ingestInCache(commentPayload as Amity.CommentPayload);
-
-      const comment = pullFromCache<Amity.InternalComment>([
-        'comment',
-        'get',
-        payload.comments[0].commentId,
-      ])!;
-
-      callback(LinkedObject.comment(comment.data));
-    }
-  };
-
-  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
-};

package/src/commentRepository/events/onCommentUnflagged.ts

@@ -1,20 +0,0 @@
-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.InternalComment}
- *
- * @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.InternalComment>,
-): Amity.Unsubscriber => createCommentEventSubscriber('comment.unflagged', callback);

package/src/commentRepository/events/onCommentUpdated.ts

@@ -1,20 +0,0 @@
-import { createCommentEventSubscriber } from './utils';
-
-/**
- * ```js
- * import { onCommentUpdated } from '@amityco/ts-sdk'
- * const dispose = onCommentUpdated(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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.InternalComment>,
-): Amity.Unsubscriber => createCommentEventSubscriber('comment.updated', callback);

package/src/commentRepository/events/onLocalCommentReactionAdded.ts

@@ -1,42 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { pullFromCache, upsertInCache } from '~/cache/api';
-import { createEventSubscriber } from '~/core/events';
-import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
-
-/**
- * ```js
- * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionAdded(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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 onLocalCommentReactionAdded = (
-  callback: Amity.Listener<Amity.InternalComment>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = ({ comment }: Amity.Events['local.comment.addReaction']) => {
-    if (!client.cache) {
-      callback(comment);
-    } else {
-      upsertInCache(['comment', 'get', comment.commentId], comment);
-
-      callback(commentLinkedObject(comment));
-    }
-  };
-
-  return createEventSubscriber(
-    client,
-    'local.comment.addReaction',
-    'local.comment.addReaction',
-    filter,
-  );
-};

package/src/commentRepository/events/onLocalCommentReactionRemoved.ts

@@ -1,42 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { pullFromCache, upsertInCache } from '~/cache/api';
-import { createEventSubscriber } from '~/core/events';
-import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
-
-/**
- * ```js
- * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionRemoved(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} 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 onLocalCommentReactionRemoved = (
-  callback: Amity.Listener<Amity.InternalComment>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient();
-
-  const filter = ({ comment }: Amity.Events['local.comment.removeReaction']) => {
-    if (!client.cache) {
-      callback(comment);
-    } else {
-      upsertInCache(['comment', 'get', comment.commentId], comment);
-
-      callback(commentLinkedObject(comment));
-    }
-  };
-
-  return createEventSubscriber(
-    client,
-    'local.comment.removeReaction',
-    'local.comment.removeReaction',
-    filter,
-  );
-};

package/src/commentRepository/events/tests/onCommentCreated.test.ts

@@ -1,28 +0,0 @@
-import { client, comment11, textCommentPayload } from '~/utils/tests';
-import { onCommentCreated } from '../onCommentCreated';
-import { LinkedObject } from '~/utils/linkedObject';
-
-describe('onCommentCreated', () => {
-  test('it should call callback when comment have created', () => {
-    const callback = jest.fn();
-
-    const unsub = onCommentCreated(callback);
-    client.emitter.emit('comment.created', textCommentPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(LinkedObject.comment(comment11));
-  });
-
-  test('it should return an unsubscriber', () => {
-    const callback = jest.fn();
-
-    const unsub = onCommentCreated(callback);
-    unsub();
-
-    client.emitter.emit('comment.created', textCommentPayload);
-
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/commentRepository/events/tests/onCommentDeleted.test.ts

@@ -1,28 +0,0 @@
-import { client, comment11, textCommentPayload } from '~/utils/tests';
-import { onCommentDeleted } from '../onCommentDeleted';
-import { LinkedObject } from '~/utils/linkedObject';
-
-describe('onCommentDeleted', () => {
-  test('it should call callback when comment have created', () => {
-    const callback = jest.fn();
-
-    const unsub = onCommentDeleted(callback);
-    client.emitter.emit('comment.deleted', textCommentPayload);
-
-    unsub();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(LinkedObject.comment(comment11));
-  });
-
-  test('it should return an unsubscriber', () => {
-    const callback = jest.fn();
-
-    const unsub = onCommentDeleted(callback);
-    unsub();
-
-    client.emitter.emit('comment.deleted', textCommentPayload);
-
-    expect(callback).not.toHaveBeenCalled();
-  });
-});

package/src/commentRepository/events/utils.ts

@@ -1,217 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { createEventSubscriber, fireEvent } from '~/core/events';
-import { pullFromCache, pushToCache, queryCache, upsertInCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { LinkedObject } from '~/utils/linkedObject';
-import { prepareCommentFromFlaggedEvent } from '~/reactionRepository/utils/prepareReactionPayloadFromEvent';
-
-export const createCommentEventSubscriber = (
-  event: keyof Amity.MqttCommentEvents,
-  callback: Amity.Listener<Amity.InternalComment>,
-) => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.CommentPayload) => {
-    if (!client.cache) {
-      // TODO: here we are missing specific properties here!
-      callback(LinkedObject.comment(payload.comments[0]));
-    } else {
-      const processed = ['comment.flagged', 'comment.unflagged'].includes(event)
-        ? prepareCommentFromFlaggedEvent(payload)
-        : payload;
-      // NOTE: The event data should be merge with existing cache rather than replace it
-      ingestInCache(processed, undefined, false);
-
-      const { comments } = processed;
-
-      if (comments.length > 0) {
-        const comment = pullFromCache<Amity.InternalComment>([
-          'comment',
-          'get',
-          comments[0].commentId,
-        ])!;
-
-        if (['comment.created'].includes(event)) {
-          // NOTE: skip adding comment to parent comment children if it's the same user since we use the local event to update instead.
-          if (event === 'comment.created' && comment.data.userId === client.userId) return;
-
-          if (comments[0].parentId) {
-            const parentComment = pullFromCache<Amity.InternalComment>([
-              'comment',
-              'get',
-              comments[0].parentId,
-            ]);
-
-            if (parentComment?.data) {
-              // Skip to update parent childComment if current comment already exists
-              if (!parentComment.data.children.includes(comments[0].commentId)) {
-                pushToCache(['comment', 'get', comments[0].parentId], {
-                  ...parentComment.data,
-                  childrenNumber: parentComment.data.childrenNumber + 1,
-                  children: [...new Set([...parentComment.data.children, comments[0].commentId])],
-                });
-              }
-            }
-          }
-        }
-
-        if (['comment.deleted'].includes(event)) {
-          // NOTE: skip deleting comment to parent comment children if it's the same user since we use the local event to update instead.
-          if (event === 'comment.deleted' && comment.data.userId === client.userId) return;
-
-          if (comments[0].parentId) {
-            const parentComment = pullFromCache<Amity.InternalComment>([
-              'comment',
-              'get',
-              comments[0].parentId,
-            ]);
-
-            if (parentComment?.data) {
-              // Remove deleted comment in parent childComment if still exists
-              if (parentComment.data.children.includes(comments[0].commentId)) {
-                const newParentComment = {
-                  ...parentComment.data,
-                  childrenNumber: parentComment.data.childrenNumber - 1,
-                  children: [
-                    ...new Set([
-                      ...parentComment.data.children.filter(id => id !== comments[0].commentId),
-                    ]),
-                  ],
-                };
-
-                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
-              }
-            }
-          }
-
-          const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
-            ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
-          );
-
-          queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
-        }
-
-        callback(LinkedObject.comment(comment.data));
-      }
-    }
-  };
-
-  return createEventSubscriber(client, event, event, filter);
-};
-
-export const createLocalCommentEventSubscriber = (
-  event: keyof Omit<
-    Amity.LocalCommentEvents,
-    'local.comment.addReaction' | 'local.comment.removeReaction'
-  >,
-  callback: Amity.Listener<Amity.InternalComment>,
-) => {
-  const client = getActiveClient();
-
-  const filter = (payload: Amity.CommentPayload) => {
-    if (!client.cache) {
-      // TODO: here we are missing specific properties here!
-      callback(LinkedObject.comment(payload.comments[0]));
-    } else {
-      const processed = payload;
-
-      ingestInCache(processed);
-
-      const { comments } = processed;
-
-      if (comments.length > 0) {
-        const comment = pullFromCache<Amity.InternalComment>([
-          'comment',
-          'get',
-          comments[0].commentId,
-        ])!;
-
-        if (['local.comment.created'].includes(event)) {
-          if (comments[0].parentId) {
-            const parentComment = pullFromCache<Amity.InternalComment>([
-              'comment',
-              'get',
-              comments[0].parentId,
-            ]);
-
-            if (parentComment?.data) {
-              // Skip to update parent childComment if current comment already exists
-              if (!parentComment.data.children.includes(comments[0].commentId)) {
-                const newParentComment = {
-                  ...parentComment.data,
-                  childrenNumber: parentComment.data.childrenNumber + 1,
-                  children: [...new Set([...parentComment.data.children, comments[0].commentId])],
-                };
-                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
-
-                setTimeout(() => {
-                  // NOTE: This is workaround solution for emitting event not work properly.
-                  fireEvent('comment.updated', {
-                    comments: [newParentComment],
-                    commentChildren: [],
-                    files: [],
-                    users: [],
-                    communityUsers: [],
-                  });
-                }, 200);
-              }
-            }
-          }
-
-          const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
-            ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
-          );
-
-          queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
-        }
-
-        if (['local.comment.deleted'].includes(event)) {
-          if (comments[0].parentId) {
-            const parentComment = pullFromCache<Amity.InternalComment>([
-              'comment',
-              'get',
-              comments[0].parentId,
-            ]);
-
-            if (parentComment?.data) {
-              // Remove deleted comment in parent childComment if still exists
-              if (parentComment.data.children.includes(comments[0].commentId)) {
-                const newParentComment = {
-                  ...parentComment.data,
-                  childrenNumber: parentComment.data.childrenNumber - 1,
-                  children: [
-                    ...new Set([
-                      ...parentComment.data.children.filter(id => id !== comments[0].commentId),
-                    ]),
-                  ],
-                };
-                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
-
-                setTimeout(() => {
-                  // NOTE: This is workaround solution for emitting event not work properly.
-                  fireEvent('comment.updated', {
-                    comments: [newParentComment],
-                    commentChildren: [],
-                    files: [],
-                    users: [],
-                    communityUsers: [],
-                  });
-                }, 200);
-              }
-            }
-          }
-
-          const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
-            ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
-          );
-
-          queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
-        }
-
-        callback(LinkedObject.comment(comment.data));
-      }
-    }
-  };
-
-  return createEventSubscriber(client, event, event, filter);
-};

package/src/commentRepository/index.ts

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