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

package/src/message/events/onMessageUpdated.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,13 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Message Events
  */
-export const onMessageUpdated = (
-  callback: Amity.Listener<Amity.Message>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.MessagePayload) => {
-    ingestInCache(payload)
-    callback(payload.messages[0])
-  }
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'message/onMessageUpdated',
-    'v3.message.didUpdate',
-    filter,
-  )
-}
+  return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);
+};

package/src/message/observers/index.ts

@@ -1,2 +1,2 @@
-export { observeMessage } from './observeMessage'
-export { observeMessages } from './observeMessages'
+export { observeMessage } from './observeMessage';
+export { observeMessages } from './observeMessages';

package/src/message/observers/observeMessage.ts

@@ -1,13 +1,10 @@
-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 { getMessage } from '../api'
+import { getMessage } from '../api';
 
-import {
-  onMessageUpdated,
-  onMessageDeleted,
-} from '../events'
+import { onMessageUpdated, onMessageDeleted } from '../events';
 
 /**
  * ```js
@@ -30,45 +27,42 @@ import {
 export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
   messageId: Amity.Message['messageId'],
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, 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(`observeMessage(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeMessage(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (
-    result: Amity.Snapshot<Amity.Message>,
-    action: Events[number]
-  ) => {
+  const router = (result: Amity.Snapshot<Amity.Message>, action: Events[number]) => {
     // filter function
-    if (result.data?.messageId !== messageId) return
+    if (result.data?.messageId !== messageId) return;
 
-    if (callback instanceof Function) return callback(result)
+    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 disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
     onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete'))
-  )
+    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+  );
 
   if (policy !== 'no_fetch') {
     runQuery(
       createQuery(getMessage, messageId),
       result => result.data && router(result, 'onFetch'),
-      queryOptions(policy)
-    )
+      queryOptions(policy),
+    );
   }
 
   return () => {
-    log(`observeMessages(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/message/observers/observeMessages.ts

@@ -1,10 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import {
-  onMessageCreated,
-  onMessageUpdated,
-  onMessageDeleted,
-} from '../events'
+import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '../events';
 
 /**
  * ```js
@@ -25,36 +21,38 @@ import {
  */
 export const observeMessages = (
   channelId: Amity.Channel['channelId'],
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, ['onCreate', 'onUpdate', 'onDelete']>,
+  callback: Amity.ObjectListener<
+    Amity.Snapshot<Amity.Message>,
+    ['onCreate', 'onUpdate', 'onDelete']
+  >,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeMessages(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeMessages(tmpid: ${timestamp}) > listen`);
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   const router = (
     message: Amity.Snapshot<Amity.Message>,
     action: 'onCreate' | 'onUpdate' | 'onDelete',
   ) => {
-    if (message.data?.channelId !== channelId) return
+    if (message.data?.channelId !== channelId) return;
 
-    if (callback instanceof Function)
-      return callback(message)
+    if (callback instanceof Function) return callback(message);
 
-    callback.onEvent?.(action, message)
-    callback[action]?.(message)
-  }
+    callback.onEvent?.(action, message);
+    callback[action]?.(message);
+  };
 
   disposers.push(
     onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
     onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
     onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
-  )
+  );
 
   return () => {
-    log(`observeMessages(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/post/api/createPost.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,32 +22,32 @@ import { fireEvent } from '~/core/events'
  * @async
  */
 export const createPost = async <T extends Amity.PostContentType | string>(
-  bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata' | 'mentionees'> & {
-    dataType?: T,
-    data?: { [k: string]: any },
-    attachments?: { type: T, fileId: Amity.File['fileId'] }[]
+  bundle: Pick<Amity.Post, 'targetType' | 'targetId' | 'metadata' | 'mentionees' | 'tags'> & {
+    dataType?: T;
+    data?: { [k: string]: any };
+    attachments?: { type: T; fileId: Amity.File['fileId'] }[];
   },
 ): Promise<Amity.Cached<Amity.Post>> => {
-  const client = getActiveClient()
-  client.log('post/createPost', bundle)
+  const client = getActiveClient();
+  client.log('post/createPost', bundle);
 
   // API-FIX: backend rejects that we pass the dataType manually T_T
-  if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType))
-    delete bundle.dataType
+  if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
+    // eslint-disable-next-line no-param-reassign
+    delete bundle.dataType;
+  }
 
-  const { data } = await client.http.post<Amity.PostPayload>(
-    '/api/v4/posts', bundle
-  )
+  const { data } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
 
-  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.created', data)
+  fireEvent('post.created', data);
 
-  const { posts } = data
+  const { posts } = data;
 
   return {
     data: posts[0],
     cachedAt,
-  }
-}
+  };
+};

package/src/post/api/deletePost.ts

@@ -1,11 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { getCommunity } from '~/community/api'
-import { dropFromCache } from '~/cache/api'
-import { upsertInCache } from '~/cache/api'
-import { fireEvent } from '~/core/events'
+import { getCommunity } from '~/community/api';
+import { dropFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
 
-import { getPost } from './getPost'
+import { getPost } from './getPost';
 
 /**
  * ```js
@@ -23,22 +22,20 @@ import { getPost } from './getPost'
  */
 export const deletePost = async (
   postId: Amity.Post['postId'],
-  permanent: boolean = false,
+  permanent = false,
 ): Promise<Amity.Post> => {
-  const client = getActiveClient()
-  client.log('post/deletePost', postId)
+  const client = getActiveClient();
+  client.log('post/deletePost', postId);
 
-  let post = await getPost(postId)
+  const post = await getPost(postId);
 
   // API-FIX: This endpoint has not been implemented yet.
-  await client.http.delete<{ success: boolean }>(
-    `/api/v4/posts/${encodeURIComponent(postId)}`, {
-      params: {
-        postId,
-        permanent,
-      },
+  await client.http.delete<{ success: boolean }>(`/api/v4/posts/${encodeURIComponent(postId)}`, {
+    params: {
+      postId,
+      permanent,
     },
-  )
+  });
 
   // there is currently a limitation which doesn't allow us to fire event to tell that community
   // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
@@ -46,21 +43,21 @@ export const deletePost = async (
   // later when realtime events covers that for us.
   if (post.data.targetType === 'community') {
     const community = await getCommunity(post.data.targetId);
-    fireEvent('community.updated', { communities: [community.data] })
+    fireEvent('community.updated', { communities: [community.data] });
   }
 
   // to support hard deletion
-  const deleted = { ...post.data, isDeleted: true }
+  const deleted = { ...post.data, isDeleted: true };
 
-  fireEvent('post.deleted', { posts: [deleted] })
+  fireEvent('post.deleted', { posts: [deleted] });
 
   if (permanent) {
     setTimeout(() => {
-      dropFromCache(['post', 'get', postId], true)
-    }, 0)
+      dropFromCache(['post', 'get', postId], true);
+    }, 0);
   } else {
-    upsertInCache(['post', 'get', postId], {isDeleted: true})
+    upsertInCache(['post', 'get', postId], { isDeleted: true });
   }
 
-  return deleted
-}
+  return deleted;
+};

package/src/post/api/getPost.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache, dropFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -17,11 +17,9 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @category Post API
  * @async
  */
-export const getPost = async (
-  postId: Amity.Post['postId']
-): Promise<Amity.Cached<Amity.Post>> => {
-  const client = getActiveClient()
-  client.log('post/getPost', postId)
+export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/getPost', postId);
 
   let data: Amity.PostPayload;
 
@@ -29,32 +27,32 @@ export const getPost = async (
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const response = await client.http.get<Amity.PostPayload>(
       `/api/v3/posts/${encodeURIComponent(postId)}`,
-    )
+    );
 
     data = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code  === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache(['post', 'get', postId], true)
+    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
+      dropFromCache(['post', 'get', postId], true);
     }
 
     throw error;
   }
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { posts } = data
+  const { posts } = data;
 
   return {
     data: posts.find(post => post.postId === postId)!,
     cachedAt,
-  }
-}
+  };
+};
 
 /**
  * ```js
  * import { getPost } from '@amityco/ts-sdk'
- * const { data. post } = getPost.locally('foobar')
+ * const { data: post } = getPost.locally('foobar')
  * ```
  *
  * Fetches a {@link Amity.Post} object from cache
@@ -64,21 +62,18 @@ export const getPost = async (
  *
  * @category Post API
  */
-getPost.locally = (
-  postId: Amity.Post['postId']
-): Amity.Cached<Amity.Post> | undefined => {
-  const client = getActiveClient()
-  client.log('post/getPost.locally', postId)
+getPost.locally = (postId: Amity.Post['postId']): Amity.Cached<Amity.Post> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPost.locally', postId);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.Post>(['post', 'get', postId])
+  const cached = pullFromCache<Amity.Post>(['post', 'get', postId]);
 
-  if (!cached)
-    return
+  if (!cached) return;
 
   return {
     data: cached.data,
     cachedAt: cached.cachedAt,
-  }
-}
+  };
+};

package/src/post/api/getPosts.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
@@ -18,27 +18,26 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @async
  */
 export const getPosts = async (
-  postIds: Amity.Post['postId'][]
+  postIds: Amity.Post['postId'][],
 ): Promise<Amity.Cached<Amity.Post[]>> => {
-  const client = getActiveClient()
-  client.log('post/getPosts', postIds)
+  const client = getActiveClient();
+  client.log('post/getPosts', postIds);
 
   const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.PostPayload>(
-    `/api/v3/posts/list`,
-    { params: { postIds: encodedPostIds } }
-  )
+  const { data } = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
+    params: { postIds: encodedPostIds },
+  });
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   return {
     data: data.posts,
-    cachedAt
-  }
-}
+    cachedAt,
+  };
+};
 
 /**
  * ```js
@@ -53,26 +52,23 @@ export const getPosts = async (
  *
  * @category Post API
  */
-getPosts.locally = (
-  postIds: Amity.Post['postId'][]
-): Amity.Cached<Amity.Post[]> | undefined => {
-  const client = getActiveClient()
-  client.log('post/getPosts.locally', postIds)
+getPosts.locally = (postIds: Amity.Post['postId'][]): Amity.Cached<Amity.Post[]> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPosts.locally', postIds);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
   const cached = postIds
     .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
-    .filter(Boolean)
+    .filter(Boolean);
 
-  const posts = cached.map(({ data }) => data)
-  const oldest = cached.sort((a, b) => a.cachedAt! < b.cachedAt! ? -1 : 1)?.[0]
+  const posts = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
-  if (cached?.length < postIds.length)
-    return
+  if (cached?.length < postIds.length) return;
 
   return {
     data: posts,
     cachedAt: oldest.cachedAt,
-  }
-}
+  };
+};

package/src/post/api/index.ts

@@ -1,7 +1,7 @@
-export * from './queryPosts'
-export * from './getPosts'
-export * from './getPost'
+export * from './queryPosts';
+export * from './getPosts';
+export * from './getPost';
 
-export * from './createPost'
-export * from './updatePost'
-export * from './deletePost'
+export * from './createPost';
+export * from './updatePost';
+export * from './deletePost';