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

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

@@ -0,0 +1,368 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  emptyPostPayload,
+  pause,
+  post11,
+  post14,
+  postQueryResponse,
+  postQueryResponsePage2,
+} from '~/utils/tests';
+
+import { getPosts } from '../getPosts';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Post[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+const { targetId, targetType } = post11;
+const params = { targetId, targetType };
+
+describe('getPosts', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return post collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    getPosts(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    const snapshot = getSnapshot();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // cause we apply prepareChannelPayload on post raw data from server
+    const payload = postQueryResponse.data;
+
+    snapshot.data = payload.posts;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const filters: [string, Amity.PostLiveCollection, number?][] = [
+    ['not deleted', { ...params, includeDeleted: false }],
+    ['tags', { ...params, tags: ['test_tag'], includeDeleted: true }, 1],
+  ];
+
+  test.each(filters)(
+    'it should filter by %s posts',
+    async (filter, params, expectedPostIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+      const payload = postQueryResponsePage2.data;
+      const snapshotData = [payload.posts[expectedPostIdx]];
+
+      getPosts(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      const snapshot = getSnapshot();
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      snapshot.loading = false;
+      snapshot.data = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(postQueryResponse)
+      .mockResolvedValueOnce(postQueryResponsePage2);
+
+    getPosts({ ...params, includeDeleted: true }, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await pause();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await pause();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    const payload = postQueryResponse.data;
+    const payload2 = postQueryResponsePage2.data;
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2.posts, ...payload.posts];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events, Amity.Post, Amity.PostLiveCollection][] = [
+    [
+      'it should add new post to collection onCreate',
+      'post.created',
+      { ...post11, postId: 'new-post-id' },
+      params,
+    ],
+    ['it should edit post in collection onUpdate', 'post.updated', post11, params],
+    [
+      'it should update post in collection onApproved',
+      'post.approved',
+      { ...post11, postId: 'approved-post-id' },
+      params,
+    ],
+    [
+      'it should remove post in collection onDelete',
+      'post.deleted',
+      { ...post11, isDeleted: true },
+      { ...params, includeDeleted: false },
+    ],
+    ['it should remove post in collection onDeclined', 'post.declined', post11, params],
+  ];
+
+  test.each(events)('%s', async (test, event, post, params) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    getPosts(params, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [post] });
+
+    const payload = postQueryResponse.data;
+    const deletePayload = payload.posts.filter(p => p.postId !== post.postId);
+
+    snapshot.loading = false;
+    // get data based on event
+    switch (event) {
+      case 'post.created':
+      case 'post.approved':
+        snapshot.data = [post, ...payload.posts];
+        break;
+
+      case 'post.deleted':
+      case 'post.declined':
+        snapshot.data = deletePayload;
+        break;
+
+      case 'post.addReaction':
+        payload.posts[0] = post;
+        snapshot.data = payload.posts;
+        break;
+
+      default:
+        snapshot.data = payload.posts;
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const reactionEvents: [
+    string,
+    keyof Amity.Events,
+    Amity.PostPayload & { reactor: Amity.Reactor },
+  ][] = [
+    [
+      'it should update post in collection onReactionAdded',
+      'post.addReaction',
+      {
+        ...emptyPostPayload,
+        posts: [{ ...post11, reactionsCount: 1 }],
+        reactor: {
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+    [
+      'it should update post in collection onReactionRemoved',
+      'post.removeReaction',
+      {
+        ...emptyPostPayload,
+        posts: [{ ...post11, reactionsCount: 0 }],
+        reactor: {
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+  ];
+
+  test.each(reactionEvents)('%s', async (test, event, reactionPayload) => {
+    const expectedReactionCount = reactionPayload.posts[0].reactionsCount;
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    getPosts(params, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, reactionPayload);
+
+    const { reactionsCount } = callback.mock.lastCall[0].data[0];
+    expect(reactionsCount).toBe(expectedReactionCount);
+  });
+
+  /*
+   * This test was added as when isDeleted posts were queried, the getPosts api
+   * would try to delete the post when 'post.deleted' event occured, where instead
+   * it should be adding it to the collection. As getPosts is called with a
+   * param to reutrun deleted posts only
+   */
+  test('it should update posts to include deleted post', async () => {
+    const deletedPost = { ...post11, isDeleted: true };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    getPosts({ ...params, includeDeleted: true }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.deleted', {
+      ...emptyPostPayload,
+      posts: [deletedPost],
+    });
+
+    snapshot.data = [deletedPost, ...payload];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should remove approved post when feedtype reviewing', async () => {
+    const feedId = 'publishedFeed';
+    const approvedPost = { ...post14, feedId };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    getPosts(
+      { ...params, targetType: 'community', feedType: 'reviewing', includeDeleted: true },
+      callback,
+    );
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.approved', {
+      ...emptyPostPayload,
+      posts: [approvedPost],
+      feeds: [
+        {
+          ...postQueryResponsePage2.data.feeds[0],
+          targetType: 'community',
+          feedId,
+          feedType: 'published',
+        },
+      ],
+    });
+
+    snapshot.data = payload.filter(({ postId }) => postId !== approvedPost.postId);
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should remove reviewing post when feedtype published', async () => {
+    const feedId = 'publishedFeed';
+    const approvedPost = { ...post14, feedId };
+
+    const approvedFeed = {
+      ...postQueryResponsePage2.data.feeds[0],
+      feedType: 'published' as const,
+    };
+
+    postQueryResponsePage2.data.feeds = [approvedFeed];
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    getPosts(
+      { ...params, targetType: 'community', feedType: 'published', includeDeleted: true },
+      callback,
+    );
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.approved', {
+      ...emptyPostPayload,
+      posts: [approvedPost],
+      feeds: [
+        {
+          ...postQueryResponsePage2.data.feeds[0],
+          targetType: 'community',
+          feedId,
+          feedType: 'reviewing',
+        },
+      ],
+    });
+
+    snapshot.data = payload.filter(({ postId }) => postId !== approvedPost.postId);
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

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

@@ -0,0 +1,98 @@
+import { ASCApiError } from '~/core/errors';
+import { client, emptyPostPayload, posts } from '~/utils/tests';
+import { pushToCache, enableCache, disableCache } from '~/cache/api';
+
+import { getPost } from '~/postRepository/api/getPost';
+
+describe('post/api', () => {
+  const post = { postId: posts.page1[0] };
+  const post2 = { postId: posts.page1[1] };
+
+  describe('getPost.locally', () => {
+    test('should return undefined if cache is turned off', () => {
+      expect(getPost.locally(post.postId)).toBeUndefined();
+    });
+
+    test('should return undefined if post not in cache', () => {
+      enableCache();
+
+      const cachedAt = Date.now();
+
+      pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+      expect(getPost.locally(post2.postId)).toBeUndefined();
+
+      disableCache();
+    });
+
+    test('should return post if post in cache', () => {
+      enableCache();
+
+      const cachedAt = Date.now();
+
+      pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+      const data = getPost.locally(post.postId);
+
+      expect(data).toBeDefined();
+      expect(data?.data).toEqual(post);
+      expect(data?.cachedAt).toEqual(cachedAt);
+
+      disableCache();
+    });
+  });
+
+  describe('getPost', () => {
+    test('should return a post', async () => {
+      client.http.get = jest.fn().mockReturnValueOnce({
+        data: {
+          ...emptyPostPayload,
+          posts: [post],
+        },
+      });
+
+      const data = await getPost(post.postId);
+
+      expect(data).toBeDefined();
+      expect(data?.data).toEqual(post);
+    });
+
+    test('should put post into the cache after fetch', async () => {
+      enableCache();
+      client.http.get = jest.fn().mockReturnValueOnce({
+        data: {
+          ...emptyPostPayload,
+          posts: [post],
+        },
+      });
+
+      await getPost(post.postId);
+
+      expect(getPost.locally(post.postId)?.data).toEqual(post);
+
+      disableCache();
+    });
+
+    test('should return an error', async () => {
+      client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+      await expect(getPost(post.postId)).rejects.toThrow('error');
+    });
+
+    test('should return an error if post in cache but api throws not found', async () => {
+      enableCache();
+      pushToCache(['post', 'get', post.postId], post, { cachedAt: Date.now() });
+
+      client.http.get = jest
+        .fn()
+        .mockRejectedValueOnce(
+          new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+        );
+
+      await expect(getPost(post.postId)).rejects.toThrow();
+
+      expect(getPost.locally(post.postId)).toBeUndefined();
+      disableCache();
+    });
+  });
+});

package/src/reactionRepository/api/addReaction.ts

@@ -0,0 +1,115 @@
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils';
+
+/* begin_public_function
+  id: reaction.add
+*/
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk-react-native'
+ * const success = await addReaction('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction}
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * @async
+ * */
+export const addReaction = async (
+  referenceType: Amity.Reaction['referenceType'],
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reactor['reactionName'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+    referenceId,
+    referenceType,
+    reactionName,
+    referenceVersion: referenceType === 'message' ? 5 : undefined,
+  });
+
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
+
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { addReaction } from '@amityco/ts-sdk-react-native'
+ * const success = addReaction.optimistically('post', postId, 'like')
+ * ```
+ *
+ * Creates an {@link Amity.Reaction} optimistically
+ *
+ * @param referenceType The type of thing to add a {@link Amity.Reaction} to, such as a post or a comment.
+ * @param referenceId The ID of the thing to add a new {@link Amity.Reaction} to.
+ * @param reactionName Reaction name, such as a `like` or `love`.
+ * @returns The added result.
+ *
+ * @category Reaction API
+ * */
+addReaction.optimistically = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  reactionName: Amity.Reactor['reactionName'],
+): boolean | undefined => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!client.cache) return;
+
+  const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
+
+  if (!model?.data || model.data.myReactions?.includes(reactionName)) return;
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: model.data.reactionsCount + 1,
+    myReactions: [...(model.data.myReactions ?? []), reactionName],
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+    },
+  } as Amity.Models[Amity.ReactableType];
+
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
+
+  dispatchReactable(referenceType, reaction);
+
+  return reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reactionRepository/api/constants.ts

@@ -0,0 +1 @@
+export const REFERENCE_API_V5 = 5;

package/src/reactionRepository/api/index.ts

@@ -0,0 +1,2 @@
+export * from './addReaction';
+export * from './removeReaction';

package/src/reactionRepository/api/queryReactions.ts

@@ -0,0 +1,57 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toToken, toPageRaw } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { REFERENCE_API_V5 } from '~/reactionRepository/api/constants';
+
+/**
+ * ```js
+ * import { queryReactions } from '@amityco/ts-sdk-react-native'
+ * const { data: reactions, prevPage, nextPage } = await queryReactions({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Reaction} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Reaction} objects
+ *
+ * @reaction Reaction API
+ * @async
+ * */
+export const queryReactions = async (
+  query: Amity.QueryReactions,
+): Promise<Amity.Paged<Amity.Reaction, Amity.Page<string>>> => {
+  const client = getActiveClient();
+  client.log('reaction/queryReactions', query);
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const { data } = await client.http.get<Amity.ReactionPayload & Amity.Pagination>(
+    `/api/v3/reactions`,
+    {
+      params: {
+        ...params,
+        referenceVersion: REFERENCE_API_V5, // Need to put this param to make it can query reaction for message in sub-channel
+        options: {
+          token: toToken(page, 'afterbeforeraw'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
+
+  // FIXME: correct reactions type in model
+  // @ts-ignore
+  ingestInCache({ ...payload, reactions }); // Save reaction response into cache
+  ingestInCache({ ...payload, reactors: reactions[0].reactors }); // Save reactors data into cache for support reaction query
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
+
+  return { data: reactions, prevPage, nextPage };
+};

package/src/reactionRepository/api/queryReactor.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { queryReactions } from './queryReactions';
+
+/**
+ * ```js
+ * import { queryReactor } from '@amityco/ts-sdk-react-native'
+ * const { data: reactions, prevPage, nextPage } = await queryReactor({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Reactor} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Reactor} objects
+ *
+ * @reaction Reaction API
+ * @async
+ * */
+export const queryReactor = async (
+  query: Amity.QueryReactions,
+): Promise<Amity.Paged<Amity.Reactor, Amity.Page<string>>> => {
+  const client = getActiveClient();
+  client.log('reaction/queryReactor', query);
+
+  const { data, ...response } = await queryReactions(query);
+
+  return { ...response, data: data[0].reactors };
+};