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

package/src/post/observers/livePosts.ts

@@ -0,0 +1,185 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  filterByFeedType,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostApproved,
+  onPostDeclined,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+} from '../events';
+import { queryPosts } from '../api';
+
+/**
+ * ```js
+ * import { livePosts } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = livePosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, response => merge(posts, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param param.targetType the type of the target
+ * @param param.targetId the ID of the target
+ * @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 messages
+ *
+ * @category Posts Live Collection
+ */
+export const livePosts = (
+  params: Amity.PostLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Post>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`livePosts(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'post',
+    'collection',
+    { targetId: params.targetId, targetType: params.targetType },
+  ];
+
+  const responder = (data: Amity.PostLiveCollectionCache) => {
+    let posts: Amity.Post[] =
+      data.data
+        .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+    posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    if (params.includeDeleted === false) {
+      posts = filterByPropEquality(posts, 'isDeleted', false);
+    }
+
+    if (params.tags) {
+      posts = posts.filter(p => p.tags?.some(t => params.tags?.includes(t)));
+    }
+
+    if (params.targetType === 'community' && params.feedType) {
+      posts = filterByFeedType(posts, params.feedType);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: posts,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.PostActionType) => (post: Amity.Post) => {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.targetId !== post.targetId || params.targetType !== post.targetType || !collection)
+      return;
+
+    /*
+     * This is not ideal, but currently this is the only way to update the
+     * collection on post declined
+     */
+    if (action === 'onDeclined') {
+      collection.data = collection.data.filter(postId => postId !== post.postId);
+    } else {
+      collection.data = [...new Set([post.postId, ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+    const posts = collection?.data ?? [];
+
+    if (posts.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryPosts, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: posts,
+        };
+
+        if (result) {
+          data.data = [...new Set([...posts, ...result.map(getResolver('post'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onPostCreated(realtimeRouter('onCreate')),
+    onPostApproved(realtimeRouter('onApproved')),
+    onPostDeclined(realtimeRouter('onDeclined')),
+    onPostDeleted(realtimeRouter('onDelete')),
+
+    onPostUpdated(realtimeRouter('onUpdate')),
+    onPostFlagged(realtimeRouter('onFlagged')),
+    onPostUnflagged(realtimeRouter('onUnflagged')),
+    onPostReactionAdded(realtimeRouter('onReactionAdded')),
+    onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`livePosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/post/observers/observePosts.ts

@@ -59,19 +59,7 @@ export const observePosts = (
 
   const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    post: Amity.Post,
-    action:
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onApproved'
-      | 'onDeclined'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onReactionAdded'
-      | 'onReactionRemoved',
-  ) => {
+  const router = (post: Amity.Post, action: Exclude<Amity.PostActionType, 'onFetch'>) => {
     if (params.targetId !== post.targetId || params.targetType !== post.targetType) return;
 
     if (callback instanceof Function) return callback(post);

package/src/post/observers/tests/livePost.test.ts

@@ -0,0 +1,104 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generatePost,
+  user12,
+  emptyPostPayload,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+
+import { livePost } from '../livePost';
+
+describe('livePost', () => {
+  const post = generatePost();
+  const response = {
+    data: {
+      ...emptyPostPayload,
+      posts: [post],
+    } as Amity.PostPayload,
+  };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.MqttPostEvents][] = [
+    ['should get update on post.updated event', 'post.updated'],
+    ['should get update on post.deleted event', 'post.deleted'],
+    ['should get update on post.approved event', 'post.approved'],
+    ['should get update on post.declined event', 'post.declined'],
+    ['should get update on post.flagged event', 'post.flagged'],
+    ['should get update on post.unflagged event', 'post.unflagged'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(post.updatedAt),
+    };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    livePost(post.postId, callback);
+    await pause();
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+
+  test.each([
+    ['should get update on post.addReaction event', 'post.addReaction'],
+    ['should get update on post.removeReaction event', 'post.removeReaction'],
+  ] as [string, keyof Amity.MqttPostEvents][])('%s', async (test, event) => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(post.updatedAt),
+    };
+    const reactor: Amity.Reaction = {
+      createdAt: getFutureDate(post.updatedAt),
+      reactionId: 'like',
+      reactionName: 'like',
+      referenceId: post.postId,
+      referenceType: 'post',
+      userId: user12.userId,
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    livePost(post.postId, callback);
+    await pause();
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [update], reactor });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+});

package/src/post/observers/tests/livePosts.test.ts

@@ -0,0 +1,366 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  connectClient,
+  disconnectClient,
+  post11,
+  post14,
+  postQueryResponse,
+  postQueryResponsePage2,
+  emptyPostPayload,
+} from '~/utils/tests';
+
+import { livePosts } from '../livePosts';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Post[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+const { targetId, targetType } = post11;
+const params = { targetId, targetType };
+
+describe('livePosts', () => {
+  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);
+
+    livePosts(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'] }, 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]];
+
+      livePosts(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);
+
+    livePosts(params, 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);
+
+    livePosts(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.Reaction },
+  ][] = [
+    [
+      'it should update post in collection onReactionAdded',
+      'post.addReaction',
+      {
+        ...emptyPostPayload,
+        posts: [{ ...post11, reactionsCount: 1 }],
+        reactor: {
+          referenceId: post11.postId,
+          referenceType: 'post',
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+    [
+      'it should update post in collection onReactionRemoved',
+      'post.removeReaction',
+      {
+        ...emptyPostPayload,
+        posts: [{ ...post11, reactionsCount: 0 }],
+        reactor: {
+          referenceId: post11.postId,
+          referenceType: 'post',
+          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);
+
+    livePosts(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 livePosts api
+   * would try to delete the post when 'post.deleted' event occured, where instead
+   * it should be adding it to the collection. As livePosts 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);
+
+    livePosts({ ...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);
+
+    livePosts({ ...params, targetType: 'community', feedType: 'reviewing' }, 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);
+
+    livePosts({ ...params, targetType: 'community', feedType: 'published' }, 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));
+  });
+});