@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/poll/api/tests/getPoll.test.ts

@@ -0,0 +1,31 @@
+import { client, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { getPoll } from '../getPoll';
+
+describe('getPoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: 0d096a75-2f42-489e-8435-e3022eafb1a3
+  it('should fetch the poll', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await getPoll(poll11.pollId);
+    const { data: cachedPoll } = getPoll.locally(poll11.pollId)!;
+
+    expect(poll.pollId).toEqual(poll11.pollId);
+    expect(cachedPoll).toMatchObject(poll);
+  });
+
+  // integration_test_id: 074fdf85-bbb6-4957-a89e-26aa10871dc4
+  it('should fail to fetch if the poll does not exist', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => getPoll('non-existent-poll-id')).rejects.toThrow();
+  });
+});

package/src/poll/api/tests/votePoll.test.ts

@@ -0,0 +1,41 @@
+import { client, pause, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { onPollUpdated } from '~/poll/events';
+import { votePoll } from '../votePoll';
+import { getPoll } from '../getPoll';
+
+describe('votePoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: 2abcbca5-f845-4e96-9405-23781013738e
+  it('should vote', async () => {
+    client.http.post = jest
+      .fn()
+      .mockResolvedValueOnce({ data: { polls: [{ ...poll11, isVoted: true }] } });
+    const callback = jest.fn();
+    onPollUpdated(callback);
+
+    const { data: poll } = await votePoll(poll11.pollId, [poll11.answers[0].id]);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+    await pause();
+
+    expect(poll.isVoted).toEqual(true);
+    expect(cachedPoll).toMatchObject(poll);
+    expect(callback).toHaveBeenCalledWith(poll);
+  });
+
+  // integration_test_id: b6ab2681-7f25-47a0-bc14-f4f542a3cf80
+  it('should fail to vote for in an invalid poll', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() =>
+      votePoll('non-existent-poll-id', ['non-existent-answer-id']),
+    ).rejects.toThrow();
+  });
+});

package/src/poll/api/votePoll.ts

@@ -1,7 +1,11 @@
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: poll.vote
+*/
 /**
  * ```js
  * import { votePoll } from '@amityco/ts-sdk'
@@ -34,8 +38,11 @@ export const votePoll = async (
 
   const { polls } = data;
 
+  fireEvent('poll.updated', data);
+
   return {
     data: polls.find(poll => poll.pollId === pollId)!,
     cachedAt,
   };
 };
+/* end_public_function */

package/src/poll/events/index.ts

@@ -0,0 +1,2 @@
+export * from './onPollUpdated';
+export * from './onPollDeleted';

package/src/poll/events/onPollDeleted.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onPollDeleted } from '@amityco/ts-sdk'
+ * const dispose = onPollDeleted(poll => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Poll} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Poll Events
+ */
+export const onPollDeleted = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['poll.deleted']) => {
+    if (client.cache) ingestInCache(payload);
+
+    callback(payload.polls[0]);
+  };
+
+  return createEventSubscriber(client, 'poll/onPollDeleted', 'poll.deleted', filter);
+};

package/src/poll/events/onPollUpdated.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onPollUpdated } from '@amityco/ts-sdk'
+ * const dispose = onPollUpdated(poll => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Poll} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Poll Events
+ */
+export const onPollUpdated = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['poll.updated']) => {
+    if (client.cache) ingestInCache(payload);
+
+    callback(payload.polls[0]);
+  };
+
+  return createEventSubscriber(client, 'poll/onPollUpdated', 'poll.updated', filter);
+};

package/src/poll/observers/index.ts

@@ -0,0 +1 @@
+export * from './observePoll';

package/src/poll/observers/observePoll.ts

@@ -0,0 +1,67 @@
+import { getActiveClient } from '~/client/api';
+
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import { getPoll } from '../api';
+
+import { onPollUpdated, onPollDeleted } from '../events';
+
+/**
+ * ```js
+ * import { observePoll } from '@amityco/ts-sdk'
+ *
+ * let poll = {}
+ * const dispose = observePoll(pollId, updated => poll = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Poll}
+ *
+ * @param pollId the ID of the poll to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the poll
+ *
+ * @category Poll Observer
+ */
+export const observePoll = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+  pollId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Poll | undefined>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observePoll(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Poll | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Poll>, action: Events[number]) => {
+    if (result.data?.pollId !== pollId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onPollUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onPollDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+  );
+
+  runQuery(
+    createQuery(getPoll, pollId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
+
+  return () => {
+    log(`observePoll(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/post/api/approvePost.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.approve
+*/
+/**
+ * ```js
+ * import { approvePost } from '@amityco/ts-sdk'
+ *
+ * const { data: post } = await approvePost('postId')
+ * ```
+ *
+ * Approves a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be approved
+ * @return A {@link Amity.Post} that was approved
+ *
+ * @category Post API
+ * @async
+ */
+export const approvePost = async (
+  postId: Amity.Post['postId'],
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/approvePost', postId);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/approve`,
+  );
+
+  fireEvent('post.approved', payload);
+
+  // fire virtual event for community update
+  if (payload.posts[0].targetType === 'community') {
+    fireEvent('community.updated', payload);
+  }
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/post/api/createPost.ts

@@ -2,7 +2,11 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
+*/
 /**
  * ```js
  * import { createPost } from '@amityco/ts-sdk'
@@ -37,12 +41,14 @@ export const createPost = async <T extends Amity.PostContentType | string>(
     delete bundle.dataType;
   }
 
-  const { data } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
+  const { data: payload } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
 
+  fireEvent('post.created', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.created', data);
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   const { posts } = data;
 
@@ -51,3 +57,4 @@ export const createPost = async <T extends Amity.PostContentType | string>(
     cachedAt,
   };
 };
+/* end_public_function */

package/src/post/api/declinePost.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.decline
+*/
+/**
+ * ```js
+ * import { declinePost } from '@amityco/ts-sdk'
+ *
+ * const {data: post} = await declinePost('postId')
+ * ```
+ *
+ * Declines a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be declined
+ * @return A {@link Amity.Post} that was declined
+ *
+ * @category Post API
+ * @async
+ */
+export const declinePost = async (
+  postId: Amity.Post['postId'],
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('post/declinePost', postId);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/decline`,
+  );
+
+  // fire virtual event
+  if (payload.posts[0].targetType === 'community') {
+    fireEvent('community.updated', payload);
+  }
+
+  fireEvent('post.declined', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: payload.posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/post/api/deletePost.ts

@@ -1,11 +1,15 @@
 import { getActiveClient } from '~/client/api';
 
-import { getCommunity } from '~/community/api';
-import { dropFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
+import { upsertInCache } from '~/cache/api';
+import { getCommunity } from '~/community/api';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { getPost } from './getPost';
 
+/* begin_public_function
+  id: post.soft_delete, post.hard_delete
+*/
 /**
  * ```js
  * import { deletePost } from '@amityco/ts-sdk'
@@ -43,17 +47,34 @@ 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],
+      categories: [],
+      communityUsers: [],
+      feeds: [],
+      files: [],
+      users: [],
+    });
   }
 
   // to support hard deletion
   const deleted = { ...post.data, isDeleted: true };
 
-  fireEvent('post.deleted', { posts: [deleted] });
+  fireEvent('post.deleted', {
+    posts: [deleted],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+  });
 
   if (permanent) {
     setTimeout(() => {
-      dropFromCache(['post', 'get', postId], true);
+      pushToTombstone('post', postId);
     }, 0);
   } else {
     upsertInCache(['post', 'get', postId], { isDeleted: true });
@@ -61,3 +82,4 @@ export const deletePost = async (
 
   return deleted;
 };
+/* end_public_function */

package/src/post/api/getPost.ts

@@ -1,8 +1,15 @@
 import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: post.get
+*/
 /**
  * ```js
  * import { getPost } from '@amityco/ts-sdk'
@@ -21,23 +28,26 @@ export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cache
   const client = getActiveClient();
   client.log('post/getPost', postId);
 
-  let data: Amity.PostPayload;
+  isInTombstone('post', postId);
+
+  let payload: Amity.PostPayload;
 
   try {
     // 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;
+    payload = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache(['post', 'get', postId], true);
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('post', postId);
     }
 
     throw error;
   }
 
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
@@ -48,6 +58,7 @@ export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cache
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/post/api/getPosts.ts

@@ -2,7 +2,11 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: post.get_by_ids
+*/
 /**
  * ```js
  * import { getPosts } from '@amityco/ts-sdk'
@@ -26,10 +30,12 @@ export const getPosts = async (
   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`, {
+  const { data: payload } = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
     params: { postIds: encodedPostIds },
   });
 
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/post/api/index.ts

@@ -5,3 +5,6 @@ export * from './getPost';
 export * from './createPost';
 export * from './updatePost';
 export * from './deletePost';
+
+export * from './approvePost';
+export * from './declinePost';

package/src/post/api/queryPosts.ts

@@ -5,7 +5,11 @@ import { toToken, toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: post.query, feed.query.community_feed, feed.query.user_feed
+*/
 /**
  * ```js
  * import { queryPosts } from '@amityco/ts-sdk'
@@ -20,22 +24,14 @@ 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>>> => {
+export const queryPosts = async (
+  query: Amity.QueryPosts,
+): Promise<Amity.Cached<Amity.Paged<Amity.Post, Amity.PageRaw>>> => {
   const client = getActiveClient();
   client.log('post/queryPosts', query);
 
-  const { page = { limit: 10 }, ...params } = query;
+  const { page = { limit: 10 }, includeDeleted, ...params } = query;
+  const { dataTypes, matchingOnlyParentPost } = params;
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
@@ -43,6 +39,15 @@ export const queryPosts = async (query: {
   const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
     params: {
       ...params,
+      isDeleted: includeDeleted === false ? false : undefined,
+      /*
+       * when creating post like image, file, video BE will create 2 posts
+       * 1. parent post to store text with dataType=text
+       * 2. child post to store dataTypes post data
+       *
+       * By default BE queries only parent post
+       */
+      matchingOnlyParentPost: matchingOnlyParentPost ?? !dataTypes?.length,
       options: {
         token: toToken(page, 'afterbeforeraw'),
       },
@@ -53,12 +58,13 @@ export const queryPosts = async (query: {
   // const { paging, posts } = unwrapPayload(data)
   // unpacking
   const { paging, ...payload } = data;
+  const paperedPayload = prepareMembershipPayload(payload, 'communityUsers');
   const { posts } = payload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.PostPayload, { cachedAt });
+    ingestInCache(paperedPayload, { cachedAt });
 
     const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable];
     pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
@@ -69,6 +75,7 @@ export const queryPosts = async (query: {
 
   return { data: posts, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js