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

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),
+    });
   }
-}
+};

package/src/report/api/createReport.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
-import REFERENCE_TYPES from '../constants/referenceTypes'
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
  * ```js
@@ -17,27 +17,28 @@ import REFERENCE_TYPES from '../constants/referenceTypes'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const createReport = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
+  referenceId: string,
 ): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('report/createReport', { referenceType, referenceId })
+  const client = getActiveClient();
+  client.log('report/createReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType]
+  const { domainName } = REFERENCE_TYPES[referenceType];
 
-  const { data } = await client.http.post<Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload>(
-    `/api/v3/${domainName}/${(encodeURIComponent(referenceId))}/flag`
-  )
+  const { data } = await client.http.post<
+    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
+  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`);
 
-  if (client.cache) ingestInCache(data)
+  if (client.cache) ingestInCache(data);
 
-  const event = referenceType === 'message'
-    ? 'v3.message.didUpdate' as const
-    : `${referenceType}.flagged` as const
+  const event =
+    referenceType === 'message'
+      ? ('v3.message.didUpdate' as const)
+      : (`${referenceType}.flagged` as const);
 
-  fireEvent(event, data)
+  fireEvent(event, data);
 
-  return !!data
-}
+  return !!data;
+};

package/src/report/api/deleteReport.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import REFERENCE_TYPES from '../constants/referenceTypes'
-import { fireEvent } from '~/core/events'
+import REFERENCE_TYPES from '../constants/referenceTypes';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -17,27 +17,28 @@ import { fireEvent } from '~/core/events'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const deleteReport = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
+  referenceId: string,
 ): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('report/deleteReport', { referenceType, referenceId })
+  const client = getActiveClient();
+  client.log('report/deleteReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType]
+  const { domainName } = REFERENCE_TYPES[referenceType];
 
-  const { data } = await client.http.delete<Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload>(
-    `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`
-  )
+  const { data } = await client.http.delete<
+    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
+  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`);
 
-  if (client.cache) ingestInCache(data)
+  if (client.cache) ingestInCache(data);
 
-  const event = referenceType === 'message'
-    ? 'v3.message.didUpdate' as const
-    : `${referenceType}.unflagged` as const
+  const event =
+    referenceType === 'message'
+      ? ('v3.message.didUpdate' as const)
+      : (`${referenceType}.unflagged` as const);
 
-  fireEvent(event, data)
+  fireEvent(event, data);
 
-  return !!data
-}
+  return !!data;
+};

package/src/report/api/index.ts

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

package/src/report/api/isReportedByMe.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { synchronousWSCall } from '~/core/transports'
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
 
-import REFERENCE_TYPES from '../constants/referenceTypes'
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
  * ```js
@@ -15,23 +15,23 @@ import REFERENCE_TYPES from '../constants/referenceTypes'
  *
  * @category Report API
  * @async
- **/
+ * */
 export const isReportedByMe = async (
   referenceType: keyof typeof REFERENCE_TYPES,
-  referenceId: string
+  referenceId: string,
 ) => {
-  const client = getActiveClient()
-  client.log('report/isReportedByMe', { referenceType, referenceId })
+  const client = getActiveClient();
+  client.log('report/isReportedByMe', { referenceType, referenceId });
 
-  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType]
+  const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
 
   const { result, isFlagByMe } =
     (await synchronousWSCall<{
-      result?: boolean
-      isFlagByMe?: boolean
+      result?: boolean;
+      isFlagByMe?: boolean;
     }>(client, eventName, {
       [primaryKey]: referenceId,
-    })) ?? {}
+    })) ?? {};
 
-  return result ?? isFlagByMe ?? false
-}
+  return result ?? isFlagByMe ?? false;
+};

package/src/report/constants/referenceTypes.ts

@@ -19,4 +19,4 @@ export default {
     eventName: 'user.isFlagByMe',
     primaryKey: 'userId',
   },
-}
+};

package/src/role/api/getRole.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { pullFromCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -17,24 +17,20 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @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)
+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 { data } = await client.http.get<Amity.Role[]>(`/api/v3/roles/${roleId}`);
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache({ roles: data }, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ roles: data }, { cachedAt });
 
   return {
     data: data.find(role => role.roleId === roleId)!,
     cachedAt,
-  }
-}
+  };
+};
 
 /**
  * ```js
@@ -49,21 +45,18 @@ export const getRole = async (
  *
  * @category Role API
  */
-getRole.locally = (
-  roleId: Amity.Role['roleId']
-): Amity.Cached<Amity.Role> | undefined => {
-  const client = getActiveClient()
-  client.log('role/getRole.locally', roleId)
+getRole.locally = (roleId: Amity.Role['roleId']): Amity.Cached<Amity.Role> | undefined => {
+  const client = getActiveClient();
+  client.log('role/getRole.locally', roleId);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Role>(['role', 'get', roleId])
+  const cached = pullFromCache<Amity.Role>(['role', 'get', roleId]);
 
-  if (!cached)
-    return
+  if (!cached) return;
 
   return {
     data: cached.data,
     cachedAt: cached.cachedAt,
-  }
-}
+  };
+};

package/src/role/api/index.ts

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