@amityco/ts-sdk 0.0.1-beta.16 → 0.0.1-beta.17

package/src/post/observers/observePosts.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
 import {
   onPostCreated,
@@ -7,8 +7,10 @@ import {
   onPostApproved,
   onPostDeclined,
   onPostFlagged,
-  onPostUnflagged, onPostReactionAdded, onPostReactionRemoved
-} from '../events'
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+} from '../events';
 
 /**
  * ```js
@@ -30,32 +32,53 @@ import {
  *
  * @category Post Observer
  */
-export const observePosts = (params: {
-    targetType: Amity.PostTargetType,
-    targetId: Amity.Post['targetId'],
+export const observePosts = (
+  params: {
+    targetType: Amity.PostTargetType;
+    targetId: Amity.Post['targetId'];
   },
-  callback: Amity.ObjectListener<Amity.Post, ['onCreate', 'onUpdate', 'onDelete', 'onApproved', 'onDeclined', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>
+  callback: Amity.ObjectListener<
+    Amity.Post,
+    [
+      'onCreate',
+      'onUpdate',
+      'onDelete',
+      'onApproved',
+      'onDeclined',
+      'onFlagged',
+      'onUnflagged',
+      'onReactionAdded',
+      'onReactionRemoved',
+    ]
+  >,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observePosts(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observePosts(tmpid: ${timestamp}) > listen`);
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   const router = (
     post: Amity.Post,
-    action: 'onCreate' | 'onUpdate' | 'onDelete' | 'onApproved' | 'onDeclined' | 'onFlagged' | 'onUnflagged' | 'onReactionAdded' | 'onReactionRemoved'
+    action:
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onApproved'
+      | 'onDeclined'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved',
   ) => {
-    if (params.targetId !== post.targetId
-      || params.targetType !== post.targetType)
-      return
+    if (params.targetId !== post.targetId || params.targetType !== post.targetType) return;
 
-    if (callback instanceof Function) return callback(post)
+    if (callback instanceof Function) return callback(post);
 
-    callback.onEvent?.(action, post)
-    callback[action]?.(post)
-  }
+    callback.onEvent?.(action, post);
+    callback[action]?.(post);
+  };
 
   disposers.push(
     onPostCreated(post => router(post, 'onCreate')),
@@ -67,10 +90,10 @@ export const observePosts = (params: {
     onPostUnflagged(post => router(post, 'onUnflagged')),
     onPostReactionAdded(post => router(post, 'onReactionAdded')),
     onPostReactionRemoved(post => router(post, 'onReactionRemoved')),
-  )
+  );
 
   return () => {
-    log(`observePosts(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observePosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/reaction/api/addReaction.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api'
+import { upsertInCache, pullFromCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils'
+import { dispatchReactable, fetchReference } from '../utils';
 
 /**
  * ```js
@@ -19,29 +19,30 @@ import { dispatchReactable, fetchReference } from '../utils'
  *
  * @category Reaction API
  * @async
- **/
+ * */
 export const addReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
+  reactionName: Amity.Reaction['reactionName'],
 ): Promise<boolean> => {
-  const client = getActiveClient()
+  const client = getActiveClient();
   client.log('reaction/createReaction', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
 
-  await client.http.post<{ addedId: 'string' }>(
-    '/api/v2/reactions',
-    { referenceId, referenceType, reactionName }
-  )
+  await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
 
-  const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model.data)
+  const model = await fetchReference(referenceType, referenceId);
+  dispatchReactable(referenceType, model.data);
 
-  return model.data.myReactions?.includes(reactionName) ?? false
-}
+  return model.data.myReactions?.includes(reactionName) ?? false;
+};
 
 /**
  * ```js
@@ -57,24 +58,28 @@ export const addReaction = async (
  * @returns The added result.
  *
  * @category Reaction API
- **/
+ * */
 addReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
+  reactionName: Amity.Reaction['reactionName'],
 ): boolean | undefined => {
-  const client = getActiveClient()
+  const client = getActiveClient();
   client.log('reaction/createReaction.optimistically', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([referenceType, 'get', referenceId])
+  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
 
-  if (!model?.data || model.data.myReactions?.includes(reactionName)) return
+  if (!model?.data || model.data.myReactions?.includes(reactionName)) return;
 
   const reaction = {
     ...model.data,
@@ -84,11 +89,11 @@ addReaction.optimistically = (
       ...model.data.reactions,
       [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
     },
-  } as Amity.Model[Amity.ReactableType]
+  } as Amity.Model[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 })
+  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
 
-  dispatchReactable(referenceType, reaction)
+  dispatchReactable(referenceType, reaction);
 
-  return reaction?.myReactions?.includes(reactionName) ?? false
-}
+  return reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reaction/api/index.ts

@@ -1,2 +1,2 @@
-export * from './addReaction'
-export * from './removeReaction'
+export * from './addReaction';
+export * from './removeReaction';

package/src/reaction/api/removeReaction.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api'
+import { upsertInCache, pullFromCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils'
+import { dispatchReactable, fetchReference } from '../utils';
 
 /**
  * ```js
@@ -19,29 +19,28 @@ import { dispatchReactable, fetchReference } from '../utils'
  *
  * @category Reaction API
  * @async
- **/
+ * */
 export const removeReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
+  reactionName: Amity.Reaction['reactionName'],
 ): Promise<boolean> => {
-  const client = getActiveClient()
+  const client = getActiveClient();
   client.log('reaction/removeReaction', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
 
-  await client.http.delete<{ removedId: string }>(
-    `/api/v2/reactions`,
-    { data: { referenceId, referenceType, reactionName } }
-  )
+  await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
+    data: { referenceId, referenceType, reactionName },
+  });
 
-  const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model.data)
+  const model = await fetchReference(referenceType, referenceId);
+  dispatchReactable(referenceType, model.data);
 
-  return !model.data.myReactions?.includes(reactionName) ?? false
-}
+  return !model.data.myReactions?.includes(reactionName) ?? false;
+};
 
 /**
  * ```js
@@ -57,24 +56,28 @@ export const removeReaction = async (
  * @returns The added result.
  *
  * @category Reaction API
- **/
+ * */
 removeReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
+  reactionName: Amity.Reaction['reactionName'],
 ): boolean | undefined => {
-  const client = getActiveClient()
+  const client = getActiveClient();
   client.log('reaction/removeReaction.optimistically', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([referenceType, 'get', referenceId])
+  const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
 
-  if (!model?.data || !model.data.myReactions?.includes(reactionName)) return
+  if (!model?.data || !model.data.myReactions?.includes(reactionName)) return;
 
   const reaction = {
     ...model.data,
@@ -84,11 +87,11 @@ removeReaction.optimistically = (
       ...model.data.reactions,
       [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
     },
-  } as Amity.Model[Amity.ReactableType]
+  } as Amity.Model[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 })
+  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
 
-  dispatchReactable(referenceType, reaction)
+  dispatchReactable(referenceType, reaction);
 
-  return !reaction?.myReactions?.includes(reactionName) ?? false
-}
+  return !reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reaction/events/index.ts

@@ -1 +1 @@
-export * from './onReactionRemoved'
+export * from './onReactionRemoved';

package/src/reaction/events/onReactionAdded.ts

@@ -1,10 +1,10 @@
-import { getActiveClient } from '~/client/api'
-import { pullFromCache } from '~/cache/api'
-import { ingestInCache} from '~/cache/api/ingestInCache'
-import { createEventSubscriber } from '~/core/events'
-import { getResolver } from '~/core/model'
-import { onPostReactionAdded } from '~/post/events'
-import { onCommentReactionAdded } from '~/comment/events'
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { getResolver } from '~/core/model';
+import { onPostReactionAdded } from '~/post/events';
+import { onCommentReactionAdded } from '~/comment/events';
 
 /**
  * ```js
@@ -22,43 +22,47 @@ import { onCommentReactionAdded } from '~/comment/events'
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
- **/
+ * */
 export const onReactionAdded = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>,
 ): Amity.Unsubscriber => {
   const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
     if (getResolver(referenceType)(model as any) === referenceId) {
-      callback(model)
+      callback(model);
     }
-  }
+  };
 
   if (referenceType === 'message') {
-    const client = getActiveClient()
+    const client = getActiveClient();
 
     const filter = (payload: Amity.MessagePayload) => {
-      const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messages[0].messageId])
-      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount
+      const cached = pullFromCache<Amity.Message>([
+        'message',
+        'get',
+        payload.messages[0].messageId,
+      ]);
+      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount;
 
-      ingestInCache(payload)
+      ingestInCache(payload);
 
       if (isReactionEvent) {
-        callbackWrapper(payload.messages[0])
+        callbackWrapper(payload.messages[0]);
       }
-    }
+    };
 
     return createEventSubscriber(
       client,
       'reaction/onReactionAdded',
       'v3.message.didUpdate',
-      filter
-    )
+      filter,
+    );
   }
 
   if (referenceType === 'post') {
-    return onPostReactionAdded(callbackWrapper)
+    return onPostReactionAdded(callbackWrapper);
   }
 
-  return onCommentReactionAdded(callbackWrapper)
-}
+  return onCommentReactionAdded(callbackWrapper);
+};

package/src/reaction/events/onReactionRemoved.ts

@@ -1,10 +1,10 @@
-import { getActiveClient } from '~/client/api'
-import { pullFromCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { createEventSubscriber } from '~/core/events'
-import { getResolver } from '~/core/model'
-import { onPostReactionRemoved } from '~/post/events'
-import { onCommentReactionRemoved } from '~/comment/events'
+import { getActiveClient } from '~/client/api';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { getResolver } from '~/core/model';
+import { onPostReactionRemoved } from '~/post/events';
+import { onCommentReactionRemoved } from '~/comment/events';
 
 /**
  * ```js
@@ -22,43 +22,47 @@ import { onCommentReactionRemoved } from '~/comment/events'
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
- **/
+ * */
 export const onReactionRemoved = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  callback: Amity.Listener<Amity.Model[typeof referenceType]>
+  callback: Amity.Listener<Amity.Model[typeof referenceType]>,
 ): Amity.Unsubscriber => {
   const callbackWrapper = (model: Amity.Model[typeof referenceType]) => {
     if (getResolver(referenceType)(model as any) === referenceId) {
-      callback(model)
+      callback(model);
     }
-  }
+  };
 
   if (referenceType === 'message') {
-    const client = getActiveClient()
+    const client = getActiveClient();
 
     const filter = (payload: Amity.MessagePayload) => {
-      const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messages[0].messageId])
-      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount
+      const cached = pullFromCache<Amity.Message>([
+        'message',
+        'get',
+        payload.messages[0].messageId,
+      ]);
+      const isReactionEvent = cached?.data?.reactionsCount !== payload.messages[0].reactionsCount;
 
-      ingestInCache(payload)
+      ingestInCache(payload);
 
       if (isReactionEvent) {
-        callbackWrapper(payload.messages[0])
+        callbackWrapper(payload.messages[0]);
       }
-    }
+    };
 
     return createEventSubscriber(
       client,
       'reaction/onReactionRemoved',
       'v3.message.didUpdate',
-      filter
-    )
+      filter,
+    );
   }
 
   if (referenceType === 'post') {
-    return onPostReactionRemoved(callbackWrapper)
+    return onPostReactionRemoved(callbackWrapper);
   }
 
-  return onCommentReactionRemoved(callbackWrapper)
-}
+  return onCommentReactionRemoved(callbackWrapper);
+};

package/src/reaction/utils/dispatchReactable.ts

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

package/src/reaction/utils/fetchReference.ts

@@ -1,18 +1,15 @@
-import { getMessage } from '~/message/api'
-import { getPost } from '~/post/api'
-import { getComment } from '~/comment/api'
+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)
-  else if (referenceType === 'post')
-    return getPost(referenceId)
-  else if (referenceType === 'comment')
-    return getComment(referenceId)
+  if (referenceType === 'message') return getMessage(referenceId);
+  if (referenceType === 'post') return getPost(referenceId);
+  if (referenceType === 'comment') return getComment(referenceId);
 
-  throw new Error(`Incorrect referenceType: ${referenceType}`)
-}
+  throw new Error(`Incorrect referenceType: ${referenceType}`);
+};

package/src/reaction/utils/index.ts

@@ -1,3 +1,3 @@
-export * from './dispatchReactable'
-export * from './fetchReference'
-export * from './preparePayloadForCache'
+export * from './dispatchReactable';
+export * from './fetchReference';
+export * from './preparePayloadForCache';

package/src/reaction/utils/preparePayloadForCache.ts

@@ -1,45 +1,53 @@
-import { pullFromCache } from '~/cache/api'
-import { getActiveClient } from '~/client/api'
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
 
 /** @hidden */
-export const preparePayloadForCache = <T extends 'post.addReaction' | 'post.removeReaction' | 'comment.addReaction' | 'comment.removeReaction'>(
+export const preparePayloadForCache = <
+  T extends
+    | 'post.addReaction'
+    | 'post.removeReaction'
+    | 'comment.addReaction'
+    | 'comment.removeReaction',
+>(
   event: T,
   payload: Amity.Events[T],
 ) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   if (client.userId !== payload.reactor.userId) {
-    return
+    return;
   }
 
-  let model: Amity.Reactable
-  let cached: Amity.Reactable | undefined
+  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
+    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
+    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
+    return;
   }
 
   if (event === 'post.addReaction' || event === 'comment.addReaction') {
     if (cached.myReactions.includes(payload.reactor.reactionName)) {
-      return
+      return;
     }
 
-    Object.assign(model, { myReactions: [...cached.myReactions, payload.reactor.reactionName] })
+    Object.assign(model, { myReactions: [...cached.myReactions, payload.reactor.reactionName] });
   } else {
     if (!cached.myReactions.includes(payload.reactor.reactionName)) {
-      return
+      return;
     }
 
-    Object.assign(model, { myReactions: cached.myReactions.filter(x => x !== payload.reactor.reactionName) })
+    Object.assign(model, {
+      myReactions: cached.myReactions.filter(x => x !== payload.reactor.reactionName),
+    });
   }
-}
+};