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

package/src/poll/api/getPoll.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getPoll } from '@amityco/ts-sdk'
+ * const poll = await getPoll('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Poll} object
+ *
+ * @param pollId the ID of the {@link Amity.Poll} to fetch
+ * @returns the associated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const getPoll = async (pollId: Amity.Poll['pollId']): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('poll/getPoll', pollId);
+
+  const { data } = await client.http.get<Amity.PollPayload>(`/api/v3/polls/${pollId}`);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getPoll } from '@amityco/ts-sdk'
+ * const poll = getPoll.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Poll} object
+ *
+ * @param pollId the ID of the {@link Amity.Poll} to fetch
+ * @returns the associated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ */
+getPoll.locally = (pollId: Amity.Poll['pollId']): Amity.Cached<Amity.Poll> | undefined => {
+  const client = getActiveClient();
+  client.log('poll/getPoll', pollId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Poll>(['poll', 'get', pollId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/poll/api/index.ts

@@ -0,0 +1,7 @@
+export * from './getPoll';
+
+export * from './createPoll';
+export * from './closePoll';
+export * from './deletePoll';
+
+export * from './votePoll';

package/src/poll/api/votePoll.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { votePoll } from '@amityco/ts-sdk'
+ * const voted = await votePoll(pollId)
+ * ```
+ *
+ * Votes for an {@link Amity.Poll}
+ *
+ * @param pollId The ID of the {@link Amity.Poll} to vote
+ * @param answerIds The IDs of the {@link Amity.Poll} answers to vote {@link Amity.Poll}
+ * @returns the updated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const votePoll = async (
+  pollId: Amity.Poll['pollId'],
+  answerIds: string[],
+): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('user/votePoll', pollId);
+
+  const { data } = await client.http.post<Amity.PollPayload>(
+    `/api/v3/polls/${encodeURIComponent(pollId)}/votes`,
+    { pollId, answerIds },
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};

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

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, Amity.PageRaw>>> => {
-  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
@@ -88,28 +86,28 @@ export const queryPosts = async (
 queryPosts.locally = (
   query: Parameters<typeof queryPosts>[0],
 ): Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>> | undefined => {
-  const client = getActiveClient()
-  client.log('post/queryPosts.locally', query)
+  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,
-  }
-
-}
+  };
+};