@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/postRepository/api/deletePost.ts

@@ -0,0 +1,79 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { upsertInCache } from '~/cache/api';
+import { getCommunity } from '~/communityRepository/api/getCommunity';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+import { getPost } from './getPost';
+
+/**
+ * ```js
+ * import { deletePost } from '@amityco/ts-sdk-react-native'
+ * const success = await deletePost('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @private
+ * @async
+ */
+export const deletePost = async (
+  postId: Amity.Post['postId'],
+  permanent = false,
+): Promise<Amity.Post> => {
+  const client = getActiveClient();
+
+  const post = await getPost(postId);
+
+  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`
+  // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+  // 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],
+      categories: [],
+      communityUsers: [],
+      feeds: [],
+      files: [],
+      users: [],
+    });
+  }
+
+  // to support hard deletion
+  const deleted = { ...post.data, isDeleted: true };
+
+  fireEvent('post.deleted', {
+    posts: [deleted],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+  });
+
+  if (permanent) {
+    setTimeout(() => {
+      pushToTombstone('post', postId);
+    }, 0);
+  } else {
+    upsertInCache(['post', 'get', postId], { isDeleted: true });
+  }
+
+  return deleted;
+};

package/src/postRepository/api/editPost.ts

@@ -0,0 +1,58 @@
+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.edit, post.edit.custom_post
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk-react-native'
+ * const updated = await PostRepository.editPost(postId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Post}
+ *
+ * @param postId The ID of the {@link Amity.Post} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Post} object
+ *
+ * @category Post API
+ * @async
+ */
+export const editPost = async <T extends Amity.PostContentType>(
+  postId: Amity.Post['postId'],
+  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'> & {
+    attachments?: {
+      type: T;
+      fileId: Amity.File['fileId'];
+    }[];
+  },
+): Promise<Amity.Cached<Amity.Post>> => {
+  const client = getActiveClient();
+  client.log('user/editPost', patch);
+
+  const { data: payload } = await client.http.put<Amity.PostPayload>(
+    `/api/v4/posts/${encodeURIComponent(postId)}`,
+    patch,
+  );
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('post.updated', data);
+
+  const { posts } = data;
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/postRepository/api/flagPost.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: post.flag
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk-react-native'
+ * const flagged = await PostRepository.flagPost(postId)
+ * ```
+ *
+ * @param postId of the post to flag
+ * @returns a boolean
+ *
+ * @category Post API
+ * @async
+ * */
+export const flagPost = async (postId: Amity.Post['postId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('post/flagPost', postId);
+
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/posts/${encodeURIComponent(postId)}/flag`,
+  );
+
+  if (client.cache) {
+    ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+  }
+
+  fireEvent('post.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/postRepository/api/getPost.ts

@@ -0,0 +1,86 @@
+import { getActiveClient } from '~/client/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';
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk-react-native'
+ * const { data: post } = await getPost('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Post} object
+ *
+ * @param postId the ID of the {@link Amity.Post} to fetch
+ * @returns the associated {@link Amity.Post} object
+ *
+ * @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);
+
+  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)}`,
+    );
+    payload = response.data;
+  } catch (error) {
+    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 });
+
+  const { posts } = data;
+
+  return {
+    data: posts.find(post => post.postId === postId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getPost } from '@amityco/ts-sdk-react-native'
+ * const { data: post } = getPost.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Post} object from cache
+ *
+ * @param postId the ID of the {@link Amity.Post} to fetch
+ * @returns the associated {@link Amity.Post} object
+ *
+ * @category Post API
+ */
+getPost.locally = (postId: Amity.Post['postId']): Amity.Cached<Amity.Post> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPost.locally', postId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Post>(['post', 'get', postId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/postRepository/api/getPostByIds.ts

@@ -0,0 +1,100 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+/* begin_public_function
+  id: post.get_by_ids
+*/
+/**
+ * ```js
+ * import { getPostByIds } from '@amityco/ts-sdk-react-native'
+ * const { data: posts } = await getPostByIds(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ * @async
+ */
+export const getPostByIds = async (
+  postIds: Amity.Post['postId'][],
+): Promise<Amity.Cached<Amity.Post[]>> => {
+  const client = getActiveClient();
+  client.log('post/getPostByIds', postIds);
+
+  const encodedPostIds = postIds.map(postId => encodeURIComponent(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/list`, {
+      params: { postIds: encodedPostIds },
+    });
+
+    payload = response.data;
+  } catch (error) {
+    postIds.forEach(postId => {
+      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 });
+
+  return {
+    data: data.posts,
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { getPostByIds } from '@amityco/ts-sdk-react-native'
+ * const { data: posts } = getPostByIds.locally(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects from cache
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ */
+
+getPostByIds.locally = (
+  postIds: Amity.Post['postId'][],
+): Amity.Cached<Amity.Post[]> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPostByIds.locally', postIds);
+
+  if (!client.cache) return;
+
+  const cached = postIds
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean);
+
+  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;
+
+  return {
+    data: posts,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/postRepository/api/hardDeletePost.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+
+import { deletePost } from './deletePost';
+
+/* begin_public_function
+  id: post.hard_delete
+*/
+/**
+ * ```js
+ * import { hardDeletePost } from '@amityco/ts-sdk-react-native'
+ * const success = await hardDeletePost('foobar')
+ * ```
+ *
+ * Hard deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be hard delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @category Post API
+ * @async
+ */
+export const hardDeletePost = async (postId: Amity.Post['postId']): Promise<Amity.Post> => {
+  const client = getActiveClient();
+  client.log('post/hardDeletePost', postId);
+
+  const hardDeleted = await deletePost(postId, true);
+
+  return hardDeleted;
+};
+/* end_public_function */

package/src/postRepository/api/index.ts

@@ -0,0 +1,16 @@
+export * from './getPostByIds';
+
+export * from './createPost';
+export * from './updatePost';
+export * from './editPost';
+
+export * from './deletePost';
+export * from './softDeletePost';
+export * from './hardDeletePost';
+
+export * from './approvePost';
+export * from './declinePost';
+
+export * from './flagPost';
+export * from './unflagPost';
+export * from './isPostFlaggedByMe';

package/src/postRepository/api/isPostFlaggedByMe.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
+
+/* begin_public_function
+  id: post.check_flag_by_me
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk-react-native'
+ * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
+ * ```
+ *
+ * @param postId of the post to check if flagged by current user
+ * @returns `true` if the post is flagged by me, `false` if doesn't.
+ *
+ * @category Post API
+ * @async
+ * */
+export const isPostFlaggedByMe = async (postId: Amity.Post['postId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('post/isPostFlaggedByMe', postId);
+
+  const { result, isFlagByMe } =
+    (await synchronousWSCall<{
+      result?: boolean;
+      isFlagByMe?: boolean;
+    }>(client, 'v3/post.isflagbyme', {
+      postId,
+    })) ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+/* end_public_function */

package/src/postRepository/api/queryPosts.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api';
+
+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';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+/**
+ * ```js
+ * import { queryPosts } from '@amityco/ts-sdk-react-native'
+ * const { data: posts, prevPage, nextPage } = await queryPosts({ targetId, targetType })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ * @async
+ */
+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 }, includeDeleted, ...params } = query;
+  const { dataTypes, matchingOnlyParentPost } = params;
+
+  // 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: {
+      ...params,
+      isDeleted: inferIsDeleted(includeDeleted),
+      /*
+       * 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'),
+      },
+    },
+  });
+
+  // API-FIX: backend should answer Amity.Response (2)
+  // 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(paperedPayload, { cachedAt });
+
+    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);
+
+  return { data: posts, cachedAt, prevPage, nextPage };
+};

package/src/postRepository/api/softDeletePost.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+
+import { deletePost } from './deletePost';
+
+/* begin_public_function
+  id: post.soft_delete
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk-react-native'
+ * const success = await PostRepository.softDeletePost('foobar')
+ * ```
+ *
+ * Soft deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to soft delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @category Post API
+ * @async
+ */
+export const softDeletePost = async (postId: Amity.Post['postId']): Promise<Amity.Post> => {
+  const client = getActiveClient();
+  client.log('post/softDeletePost', postId);
+
+  const softDeleted = await deletePost(postId, false);
+
+  return softDeleted;
+};
+/* end_public_function */

package/src/postRepository/api/tests/getPostByIds.test.ts

@@ -0,0 +1,18 @@
+import { client, connectClient, disconnectClient, post11, post12 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { getPostByIds } from '~/postRepository/api/getPostByIds';
+
+describe('getPostByIds', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return Error: 400400 when getPostByIds from invalid postId', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getPostByIds([post11.postId, post12.postId])).rejects.toThrow();
+  });
+});

package/src/postRepository/api/tests/getPosts.test.ts

@@ -0,0 +1,18 @@
+import { getPostByIds } from '~/postRepository/api/getPostByIds';
+import { client, connectClient, disconnectClient, post11, post12 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+describe('getPostByIds', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return Error: 400400 when getPostByIds from invalid postId', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getPostByIds([post11.postId, post12.postId])).rejects.toThrow();
+  });
+});

package/src/postRepository/api/tests/queryPosts.test.ts

@@ -0,0 +1,79 @@
+import { client, postQueryResponse, post11 } from '~/utils/tests';
+
+import { queryPosts } from '../queryPosts';
+
+const { targetId, targetType } = post11;
+const params = { targetId, targetType };
+
+describe('queryPosts', () => {
+  test('it should return posts', async () => {
+    const { posts: expected } = postQueryResponse.data;
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data } = await queryPosts(params);
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryPosts(params)).rejects.toThrow('error');
+  });
+
+  test('it should send matchingOnlyParentPost as true if there are no dataTypes', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts(params);
+
+    const mockFnParams = mockFn.mock.lastCall;
+
+    expect(mockFnParams).toBeDefined();
+    expect(mockFnParams).toHaveLength(2);
+    expect(mockFnParams[1].params.matchingOnlyParentPost).toBe(true);
+  });
+
+  test('it should send matchingOnlyParentPost as false if there are dataTypes', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts({ ...params, dataTypes: ['image'] });
+
+    const mockFnParams = mockFn.mock.lastCall;
+
+    expect(mockFnParams).toBeDefined();
+    expect(mockFnParams).toHaveLength(2);
+    expect(mockFnParams[1].params.matchingOnlyParentPost).toBe(false);
+  });
+
+  test('it should set isDeleted to undefined if includeDeleted is true', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts({ ...params, includeDeleted: true });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
+
+  test('it should set isDeleted to false if includeDeleted is false', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts({ ...params, includeDeleted: false });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+
+  test('it should set isDeleted to undefined if includeDeleted is undefined', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts({ ...params, includeDeleted: true });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
+});