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

package/src/post/events/index.ts

@@ -1,12 +1,12 @@
-export * from './onPostCreated'
-export * from './onPostUpdated'
-export * from './onPostDeleted'
+export * from './onPostCreated';
+export * from './onPostUpdated';
+export * from './onPostDeleted';
 
-export * from './onPostApproved'
-export * from './onPostDeclined'
+export * from './onPostApproved';
+export * from './onPostDeclined';
 
-export * from './onPostFlagged'
-export * from './onPostUnflagged'
+export * from './onPostFlagged';
+export * from './onPostUnflagged';
 
-export * from './onPostReactionAdded'
-export * from './onPostReactionRemoved'
+export * from './onPostReactionAdded';
+export * from './onPostReactionRemoved';

package/src/post/events/onPostApproved.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostApproved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.approved', callback)
+  createPostEventSubscriber('post.approved', callback);

package/src/post/events/onPostCreated.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostCreated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.created', callback)
+  createPostEventSubscriber('post.created', callback);

package/src/post/events/onPostDeclined.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostDeclined = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.declined', callback)
+  createPostEventSubscriber('post.declined', callback);

package/src/post/events/onPostDeleted.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostDeleted = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.deleted', callback)
+  createPostEventSubscriber('post.deleted', callback);

package/src/post/events/onPostFlagged.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostFlagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.flagged', callback)
+  createPostEventSubscriber('post.flagged', callback);

package/src/post/events/onPostReactionAdded.ts

@@ -1,8 +1,8 @@
-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'
+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
@@ -20,27 +20,23 @@ import { preparePayloadForCache } from '~/reaction/utils'
  * @category Post Events
  */
 export const onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.Events['post.addReaction']) => {
     if (!client.cache) {
-      callback(payload.posts[0])
+      callback(payload.posts[0]);
     } else {
-      preparePayloadForCache('post.addReaction', payload)
+      preparePayloadForCache('post.addReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { reactor, ...postPayload } = payload;
 
-      ingestInCache(postPayload as Amity.CommentPayload)
+      ingestInCache(postPayload as Amity.CommentPayload);
 
-      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
 
-      callback(post.data)
+      callback(post.data);
     }
-  }
+  };
 
-  return createEventSubscriber(
-    client,
-    'post.addReaction',
-    'post.addReaction',
-    filter
-  )
-}
+  return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+};

package/src/post/events/onPostReactionRemoved.ts

@@ -1,8 +1,8 @@
-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'
+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
@@ -20,27 +20,23 @@ import { preparePayloadForCache } from '~/reaction/utils'
  * @category Post Events
  */
 export const onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.Events['post.removeReaction']) => {
     if (!client.cache) {
-      callback(payload.posts[0])
+      callback(payload.posts[0]);
     } else {
-      preparePayloadForCache('post.removeReaction', payload)
+      preparePayloadForCache('post.removeReaction', payload);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { reactor, ...postPayload } = payload;
 
-      ingestInCache(postPayload as Amity.CommentPayload)
+      ingestInCache(postPayload as Amity.CommentPayload);
 
-      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
 
-      callback(post.data)
+      callback(post.data);
     }
-  }
+  };
 
-  return createEventSubscriber(
-    client,
-    'post.removeReaction',
-    'post.removeReaction',
-    filter
-  )
-}
+  return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+};

package/src/post/events/onPostUnflagged.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostUnflagged = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.unflagged', callback)
+  createPostEventSubscriber('post.unflagged', callback);

package/src/post/events/onPostUpdated.ts

@@ -1,4 +1,4 @@
-import { createPostEventSubscriber } from './utils'
+import { createPostEventSubscriber } from './utils';
 
 /**
  * ```js
@@ -16,4 +16,4 @@ import { createPostEventSubscriber } from './utils'
  * @category Post Events
  */
 export const onPostUpdated = (callback: Amity.Listener<Amity.Post>): Amity.Unsubscriber =>
-  createPostEventSubscriber('post.updated', callback)
+  createPostEventSubscriber('post.updated', callback);

package/src/post/events/utils.ts

@@ -1,49 +1,44 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { createEventSubscriber, fireEvent } from '~/core/events'
-import { queryCache, upsertInCache, pullFromCache } from '~/cache/api'
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber, fireEvent } from '~/core/events';
+import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
 
 export const createPostEventSubscriber = (
   event: keyof Amity.MqttPostMessageEvents,
-  callback: Amity.Listener<Amity.Post>
+  callback: Amity.Listener<Amity.Post>,
 ) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.PostPayload) => {
     if (!client.cache) {
-      callback(payload.posts[0])
+      callback(payload.posts[0]);
     } else {
-      const { communities, ...others } = payload
+      const { communities, ...others } = payload;
 
-      ingestInCache(others as Amity.PostPayload)
+      ingestInCache(others as Amity.PostPayload);
 
       if (communities?.[0] && !['post.updated'].includes(event)) {
-        fireEvent('community.updated', { communities })
+        fireEvent('community.updated', { communities });
       }
 
-      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!
+      const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
 
       if (['post.created', 'post.approved', 'post.declined'].includes(event)) {
         let queries = queryCache(['post', 'query'])
           // @ts-ignore
-          ?.filter(({key}) => key[2]?.targetId === post.data.targetId);
+          ?.filter(({ key }) => key[2]?.targetId === post.data.targetId);
 
         if (event === 'post.declined') {
           // @ts-ignore
-          queries = queries?.filter(({key}) => key[2]?.feedType === 'reviewing');
+          queries = queries?.filter(({ key }) => key[2]?.feedType === 'reviewing');
         }
 
-        queries?.map(({key, data}) => upsertInCache(key, data as any, { cachedAt: -1 }));
+        queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
       }
 
-      callback(post.data)
+      callback(post.data);
     }
-  }
-
-  return createEventSubscriber(
-    client,
-    event,
-    event,
-    filter
-  )
-}
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/post/observers/index.ts

@@ -1,2 +1,2 @@
-export * from './observePosts'
-export * from './observePost'
+export * from './observePosts';
+export * from './observePost';

package/src/post/observers/observePost.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { createQuery, runQuery, queryOptions } from '~/core/query'
+import { createQuery, runQuery, queryOptions } from '~/core/query';
 
-import { getPost } from '../api'
+import { getPost } from '../api';
 
 import {
   onPostUpdated,
@@ -13,7 +13,7 @@ import {
   onPostUnflagged,
   onPostReactionAdded,
   onPostReactionRemoved,
-} from '../events'
+} from '../events';
 
 /**
  * ```js
@@ -31,38 +31,44 @@ import {
  *
  * @category Post Observer
  */
-export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onApproved', 'onDeclined', 'onFlagged', 'onUnflagged', 'onReactionAdded', 'onReactionRemoved']>(
+export const observePost = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onApproved',
+    'onDeclined',
+    'onFlagged',
+    'onUnflagged',
+    'onReactionAdded',
+    'onReactionRemoved',
+  ],
+>(
   postId: string,
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.Post | undefined>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server'
+  policy: Amity.QueryPolicy = 'cache_then_server',
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observePost(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observePost(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (
-    result: Amity.Snapshot<Amity.Post | undefined>,
-    action: Events[number]
-  ) => {
-    if (callback instanceof Function) return callback(result)
+  const router = (result: Amity.Snapshot<Amity.Post | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
 
-    if (action !== 'onFetch') callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    callback[action]?.(result)
-  }
+    callback[action]?.(result);
+  };
 
-  const realtimeRouter = (
-    result: Amity.Snapshot<Amity.Post>,
-    action: Events[number]
-  ) => {
-    if (result.data?.postId !== postId) return
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Post>, action: Events[number]) => {
+    if (result.data?.postId !== postId) return;
 
-    router(result, action)
-  }
+    router(result, action);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
     onPostUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
@@ -70,19 +76,25 @@ export const observePost = <Events extends ['onFetch', 'onUpdate', 'onDelete', '
     onPostApproved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onApproved')),
     onPostDeclined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDeclined')),
     onPostFlagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged')),
-    onPostUnflagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged')),
-    onPostReactionAdded(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded')),
-    onPostReactionRemoved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved')),
-  )
+    onPostUnflagged(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
+    ),
+    onPostReactionAdded(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
+    ),
+    onPostReactionRemoved(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
+    ),
+  );
 
   runQuery(
     createQuery(getPost, postId),
     result => (result.data || result.error) && router(result, 'onFetch'),
     queryOptions(policy),
-  )
+  );
 
   return () => {
-    log(`observePosts(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observePosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

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';