@amityco/ts-sdk 6.35.3-c7e7d80.0 → 6.35.3-dc46366a.0

package/src/postRepository/api/deletePost.ts

@@ -1,96 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { fireEvent } from '~/core/events';
-import { queryCache, upsertInCache } from '~/cache/api';
-import { getCommunity } from '~/communityRepository/api/getCommunity';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { getPost } from './getPost';
-
-/**
- * ```js
- * import { deletePost } from '@amityco/ts-sdk'
- * 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);
-
-    const communityUsersCache =
-      queryCache<Amity.RawMembership<'community'>>(['communityUsers', 'get']) ?? [];
-
-    const communityUsers = communityUsersCache
-      .filter(({ key }) => {
-        // cache key is ['communityUsers', 'get', `${communityId}#`${userId}`}]
-        if (key[0] !== 'communityUsers') return false;
-        if (key[1] !== 'get') return false;
-
-        if (typeof key[2] === 'string') return key[2].includes(community.data.communityId);
-        return false;
-      })
-      .map(({ data }) => data);
-
-    fireEvent('community.updated', {
-      communities: [community.data],
-      categories: [],
-      communityUsers,
-      feeds: [],
-      files: [],
-      users: [],
-    });
-  }
-
-  // to support hard deletion
-  const deleted = { ...post.data, isDeleted: true };
-
-  if (permanent) {
-    setTimeout(() => {
-      pushToTombstone('post', postId);
-    }, 0);
-  } else {
-    upsertInCache(['post', 'get', postId], { isDeleted: true });
-  }
-
-  fireEvent('local.post.deleted', {
-    posts: [deleted],
-    categories: [],
-    comments: [],
-    communities: [],
-    communityUsers: [],
-    feeds: [],
-    files: [],
-    postChildren: [],
-    users: [],
-    videoStreamings: [],
-  });
-
-  return LinkedObject.post(deleted);
-};

package/src/postRepository/api/editPost.ts

@@ -1,59 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: post.edit, post.edit.custom_post
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * 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('local.post.updated', data);
-
-  const { posts } = data;
-
-  return {
-    data: LinkedObject.post(posts.find(post => post.postId === postId)!),
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/postRepository/api/flagPost.ts

@@ -1,38 +0,0 @@
-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'
- * 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

@@ -1,89 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/**
- * ```js
- * import { getPost } from '@amityco/ts-sdk'
- * 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;
-
-  const result = posts.find(post => post.postId === postId)!;
-
-  return {
-    data: LinkedObject.post(result),
-    cachedAt,
-  };
-};
-
-/**
- * ```js
- * import { getPost } from '@amityco/ts-sdk'
- * 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.InternalPost>(['post', 'get', postId]);
-
-  if (!cached) return;
-
-  return {
-    data: LinkedObject.post(cached.data),
-    cachedAt: cached.cachedAt,
-  };
-};

package/src/postRepository/api/getPostByIds.ts

@@ -1,101 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: post.get_by_ids
-*/
-/**
- * ```js
- * import { getPostByIds } from '@amityco/ts-sdk'
- * 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.map(LinkedObject.post),
-    cachedAt,
-  };
-};
-/* end_public_function */
-
-/**
- * ```js
- * import { getPostByIds } from '@amityco/ts-sdk'
- * 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.InternalPost>(['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.map(LinkedObject.post),
-    cachedAt: oldest.cachedAt,
-  };
-};

package/src/postRepository/api/hardDeletePost.ts

@@ -1,31 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { deletePost } from './deletePost';
-
-/* begin_public_function
-  id: post.hard_delete
-*/
-/**
- * ```js
- * import { hardDeletePost } from '@amityco/ts-sdk'
- * 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 LinkedObject.post(hardDeleted);
-};
-/* end_public_function */

package/src/postRepository/api/index.ts

@@ -1,15 +0,0 @@
-export * from './getPostByIds';
-
-export * from './createPost';
-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

@@ -1,28 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-/* begin_public_function
-  id: post.check_flag_by_me
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * 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 {
-    data: { result },
-  } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
-
-  return result;
-};
-/* end_public_function */

package/src/postRepository/api/queryPosts.ts

@@ -1,79 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { toPageRaw, toToken } from '~/core/query';
-
-import { 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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/**
- * ```js
- * import { queryPosts } from '@amityco/ts-sdk'
- * 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.PageToken<Amity.Post>>> => {
-  const client = getActiveClient();
-  client.log('post/queryPosts', query);
-
-  const { page, limit = 10, includeDeleted, ...params } = query;
-  const { dataTypes, matchingOnlyParentPost } = params;
-
-  const options = (() => {
-    if (page) return { token: page };
-    if (limit) return { limit };
-
-    return undefined;
-  })();
-
-  // 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,
-    },
-  });
-
-  // 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 } as Amity.Serializable];
-    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
-  }
-
-  return { data: posts.map(LinkedObject.post), cachedAt, paging };
-};

package/src/postRepository/api/softDeletePost.ts

@@ -1,31 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { deletePost } from './deletePost';
-
-/* begin_public_function
-  id: post.soft_delete
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * 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 LinkedObject.post(softDeleted);
-};
-/* end_public_function */

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

@@ -1,114 +0,0 @@
-import { ASCApiError } from '~/core/errors';
-import { client, emptyPostPayload, post11, post12, user11 } from '~/utils/tests';
-import { disableCache, enableCache, pushToCache } from '~/cache/api';
-
-import { getPost } from '~/postRepository/api/getPost';
-
-describe('post/api', () => {
-  describe('getPost.locally', () => {
-    test('should return undefined if cache is turned off', () => {
-      expect(getPost.locally(post11.postId)).toBeUndefined();
-    });
-
-    test('should return undefined if post not in cache', () => {
-      enableCache();
-
-      const cachedAt = Date.now();
-
-      pushToCache(['user', 'get', post11.postedUserId], user11, { cachedAt });
-      pushToCache(['post', 'get', post11.postId], post11, { cachedAt });
-
-      expect(getPost.locally(post12.postId)).toBeUndefined();
-
-      disableCache();
-    });
-
-    test('should return post if post in cache', () => {
-      enableCache();
-
-      const cachedAt = Date.now();
-
-      pushToCache(['user', 'get', post11.postedUserId], user11, { cachedAt });
-      pushToCache(['post', 'get', post11.postId], post11, { cachedAt });
-
-      const postData = getPost.locally(post11.postId);
-
-      expect(postData).toBeDefined();
-
-      if (postData?.data) {
-        expect(postData.cachedAt).toEqual(cachedAt);
-
-        const { analytics, ...returnedData } = postData.data;
-        expect(post11).toEqual(expect.objectContaining(returnedData));
-      }
-
-      disableCache();
-    });
-  });
-
-  describe('getPost', () => {
-    test('should return a post', async () => {
-      client.http.get = jest.fn().mockReturnValueOnce({
-        data: {
-          ...emptyPostPayload,
-          posts: [post11],
-          users: [user11],
-        },
-      });
-
-      const cachedData = await getPost(post11.postId);
-
-      expect(cachedData).toBeDefined();
-
-      if (cachedData) {
-        // Linked Object will not work if the cache is disabled
-        const {
-          data: { analytics, latestComments, creator, ...returnedData },
-        } = cachedData;
-
-        expect(post11).toEqual(expect.objectContaining(returnedData));
-      }
-    });
-
-    test('should put post into the cache after fetch', async () => {
-      enableCache();
-      client.http.get = jest.fn().mockReturnValueOnce({
-        data: {
-          ...emptyPostPayload,
-          posts: [post11],
-          users: [user11],
-        },
-      });
-
-      await getPost(post11.postId);
-
-      expect(getPost.locally(post11.postId)?.data).toHaveProperty('postId', post11.postId);
-
-      disableCache();
-    });
-
-    test('should return an error', async () => {
-      client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
-
-      await expect(getPost(post11.postId)).rejects.toThrow('error');
-    });
-
-    test('should return an error if post in cache but api throws not found', async () => {
-      enableCache();
-
-      pushToCache(['user', 'get', post11.postedUserId], user11, { cachedAt: Date.now() });
-      pushToCache(['post', 'get', post11.postId], post11, { cachedAt: Date.now() });
-
-      client.http.get = jest
-        .fn()
-        .mockRejectedValueOnce(
-          new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
-        );
-
-      await expect(getPost(post11.postId)).rejects.toThrow();
-
-      expect(getPost.locally(post11.postId)).toBeUndefined();
-      disableCache();
-    });
-  });
-});