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

package/src/post/api/queryPosts.ts

@@ -1,10 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { toToken, toPageRaw } from '~/core/query'
+import { toToken, toPageRaw } from '~/core/query';
 
-import { pullFromCache, pushToCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { getResolver } from '~/core/model'
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
 
 /**
  * ```js
@@ -20,57 +20,55 @@ import { getResolver } from '~/core/model'
  * @category Post API
  * @async
  */
-export const queryPosts = async (
-  query: {
-    targetId: string,
-    targetType: Amity.Post['targetType'],
-    sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated'
-    dataType?: string
-    isDeleted?: Amity.Post['isDeleted']
-    hasFlag?: boolean
-    feedType?: 'reviewing' | 'published'
-    tags?: Amity.Taggable['tags'],
-    matchingOnlyParentPost?: boolean
-    page?: Amity.PageRaw
-  }
-): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
-  const client = getActiveClient()
-  client.log('post/queryPosts', query)
-
-  const { page = { limit: 10 }, ...params } = query
+export const queryPosts = async (query: {
+  targetId: string;
+  targetType: Amity.Post['targetType'];
+  sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
+  dataType?: string;
+  isDeleted?: Amity.Post['isDeleted'];
+  hasFlag?: boolean;
+  feedType?: 'reviewing' | 'published';
+  tags?: Amity.Taggable['tags'];
+  matchingOnlyParentPost?: boolean;
+  page?: Amity.PageRaw;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>>> => {
+  const client = getActiveClient();
+  client.log('post/queryPosts', query);
+
+  const { page = { limit: 10 }, ...params } = query;
 
   // 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.PostPayload>>>(
-  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    `/api/v4/posts`, { params: {
+  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
+    params: {
       ...params,
       options: {
         token: toToken(page, 'afterbeforeraw'),
       },
-    }, }
-  )
+    },
+  });
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, posts } = unwrapPayload(data)
   // unpacking
-  const { paging, ...payload } = data
-  const { posts } = payload
+  const { paging, ...payload } = data;
+  const { posts } = payload;
 
-  const cachedAt = client.cache && Date.now()
+  const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.PostPayload, { cachedAt })
+    ingestInCache(payload as Amity.PostPayload, { cachedAt });
 
-    const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable]
-    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging })
+    const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
   }
 
-  const nextPage = toPageRaw(paging.next)
-  const prevPage = toPageRaw(paging.previous)
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
-  return { data: posts, cachedAt, prevPage, nextPage }
-}
+  return { data: posts, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -87,29 +85,29 @@ export const queryPosts = async (
  */
 queryPosts.locally = (
   query: Parameters<typeof queryPosts>[0],
-): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
-  const client = getActiveClient()
-  client.log('post/queryPosts.locally', query)
+): Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>> | undefined => {
+  const client = getActiveClient();
+  client.log('post/queryPosts.locally', query);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query
+  const { page = { limit: 10 }, ...params } = query;
 
-  const queryKey = ['post', 'query', { ...params, options: { ...page }} as Amity.Serializable];
-  const { data, cachedAt } = pullFromCache<{posts: Pick<Amity.Post, 'postId'>[]} & Amity.Pagination>(queryKey) ?? {}
+  const queryKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ posts: Pick<Amity.Post, 'postId'>[] } & Amity.Pagination>(queryKey) ?? {};
 
-  if (!data?.posts.length)
-    return
+  if (!data?.posts.length) return;
 
   const posts: Amity.Post[] = data.posts
     .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
     .filter(Boolean)
-    .map(({ data }) => data)
+    .map(({ data }) => data);
 
-  const prevPage = toPageRaw(data?.paging.previous)
-  const nextPage = toPageRaw(data?.paging.next)
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
 
   return posts.length === data?.posts?.length
     ? { data: posts, cachedAt, prevPage, nextPage }
-    : undefined
-}
+    : undefined;
+};

package/src/post/api/updatePost.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -22,25 +22,25 @@ import { fireEvent } from '~/core/events'
  */
 export const updatePost = async (
   postId: Amity.Post['postId'],
-  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees'>,
+  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'>,
 ): Promise<Amity.Cached<Amity.Post>> => {
-  const client = getActiveClient()
-  client.log('user/updatePost', patch)
+  const client = getActiveClient();
+  client.log('user/updatePost', patch);
 
   const { data } = await client.http.put<Amity.PostPayload>(
-    `/api/v4/posts/${encodeURIComponent(postId)}`, patch,
-  )
+    `/api/v4/posts/${encodeURIComponent(postId)}`,
+    patch,
+  );
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.updated', data)
+  fireEvent('post.updated', data);
 
-  const { posts } = data
+  const { posts } = data;
 
   return {
     data: posts.find(post => post.postId === postId)!,
     cachedAt,
-  }
-
-}
+  };
+};

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