@amityco/ts-sdk 0.0.1-beta.25 → 0.0.1-beta.28

package/src/message/observers/liveMessages.ts

@@ -0,0 +1,141 @@
+/* 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 } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+
+import { onMessageCreated, onMessageDeleted, onMessageUpdated } from '../events';
+import { queryMessages } from '../api';
+
+/**
+ * ```js
+ * import { liveMessages } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = liveMessages({
+ *   channelId: Amity.Channel['channelId'];
+ * }, response => merge(messages, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Message} for a given target object
+ *
+ * @param params for querying memssages from a channel
+ * @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 Messages Live Collection
+ */
+export const liveMessages = (
+  params: Amity.MessagesLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Message>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveMessages(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 = ['message', 'collection', { channelId: params.channelId }];
+
+  const responder = (data: Amity.MessageLiveCollectionCache) => {
+    let messages: Amity.Message[] =
+      data.data
+        .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    /*
+     * for cases when message is deleted via RTE, this flag is used to get
+     * items fro cache that are deleted | !deleted
+     */
+    messages = filterByPropEquality(messages, 'isDeleted', params.isDeleted);
+
+    callback({
+      onNextPage: onFetch,
+      data: messages,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (message: Amity.Message, action: Amity.MessageActionType) => {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.channelId !== message.channelId || !collection) return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([message.messageId, ...collection.data])];
+    } else if (['onDelete'].includes(action)) {
+      collection.data = collection.data.filter(m => m !== message.messageId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
+
+    const messages = collection?.data ?? [];
+
+    if (messages.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryMessages, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: messages,
+        };
+
+        if (result) {
+          data.data = [...new Set([...messages, ...result.map(getResolver('message'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onMessageCreated(message => realtimeRouter(message, 'onCreate')),
+    onMessageDeleted(message => realtimeRouter(message, 'onDelete')),
+
+    onMessageUpdated(message => realtimeRouter(message, 'onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/message/observers/observeMessages.ts

@@ -12,7 +12,6 @@ import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '../events'
  *
  * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
  *
- * @param client the client to observe the message with
  * @param channelId the ID of the channel where to observe the messages
  * @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

package/src/message/observers/tests/liveMessages.test.ts

@@ -0,0 +1,133 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { liveMessages } from '../liveMessages';
+
+import { client, messages } from '~/utils/tests';
+import { queryMessages } from '~/message/api';
+
+describe('liveMessages', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is diabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+
+    const callback = jest.fn();
+    jest.spyOn(global.console, 'log');
+    client.http.get = jest.fn();
+
+    // call liveMessages check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveMessages({ channelId: messages.channelId }, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return message collection', async () => {
+    const returnValue = [{ messageId: messages.page1[0] }];
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId: messages.channelId }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ channelId: messages.channelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: returnValue,
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should filter deleted messages based on param', async () => {
+    // mock response of queryMessages with a deleted message
+    const returnValue = [
+      { messageId: messages.page1[0], isDeleted: true },
+      { messageId: messages.page1[1], isDeleted: false },
+    ];
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId: messages.channelId, isDeleted: false }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ channelId: messages.channelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [returnValue[1]],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    // mock nextPage()
+  });
+
+  test('it should add new message to collection onCreate', () => {
+    // new message should be added to top of collection
+  });
+
+  test('it should update message in collection onUpdate', () => {
+    // updated message should be reflected in collection
+  });
+
+  test('it should delete message from collection onDelete', () => {
+    // should remove message from collection on delete
+  });
+
+  test('it should get messages from cache if present', () => {
+    // push message with Id in collection response to cache
+    // get request to get that messageId should not be called
+  });
+});

package/src/post/api/queryPosts.ts

@@ -20,18 +20,9 @@ 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);
 

package/src/post/observers/index.ts

@@ -1,2 +1,3 @@
 export * from './observePosts';
 export * from './observePost';
+export * from './livePosts';

package/src/post/observers/livePosts.ts

@@ -0,0 +1,171 @@
+/* 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,
+  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 targetType the type of the target
+ * @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) ?? [];
+
+    posts = filterByPropEquality(posts, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: posts,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (post: Amity.Post, action: Amity.PostActionType) => {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.targetId !== post.targetId || params.targetType !== post.targetType || !collection)
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([post.postId, ...collection.data])];
+    } else if (['onDelete', 'onDeclined'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== post.postId);
+    }
+
+    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(post => realtimeRouter(post, 'onCreate')),
+    onPostApproved(post => realtimeRouter(post, 'onApproved')),
+    onPostDeclined(post => realtimeRouter(post, 'onDeclined')),
+    onPostDeleted(post => realtimeRouter(post, 'onDelete')),
+
+    onPostUpdated(post => realtimeRouter(post, 'onUpdate')),
+    onPostFlagged(post => realtimeRouter(post, 'onFlagged')),
+    onPostUnflagged(post => realtimeRouter(post, 'onUnflagged')),
+    onPostReactionAdded(post => realtimeRouter(post, 'onReactionAdded')),
+    onPostReactionRemoved(post => realtimeRouter(post, '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/tests/api/getPost.test.ts

@@ -0,0 +1,88 @@
+import { ASCApiError } from '~/core/errors';
+import { client, posts } from '~/utils/tests';
+import { pushToCache, enableCache, disableCache } from '~/cache/api';
+
+import { getPost } from '~/post/api';
+
+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: { 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: { 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/post/tests/api/queryPosts.test.ts

@@ -0,0 +1,23 @@
+import { queryPosts } from '~/post/api';
+import { client, posts } from '~/utils/tests';
+
+describe('post/api', () => {
+  test('should return a post query', async () => {
+    const returnValue = [{ postId: posts.page1[0] }];
+
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        posts: returnValue,
+        paging: {},
+      },
+    });
+
+    const data = await queryPosts({
+      targetId: posts.targetId,
+      targetType: posts.targetType,
+    });
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(returnValue);
+  });
+});

package/src/reaction/api/queryReactions.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
-import { toToken, toPage } from '~/core/query';
+import { toToken, toPageRaw } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -19,34 +20,33 @@ import { toToken, toPage } from '~/core/query';
  * @reaction Reaction API
  * @async
  * */
-export const queryReactions = async (query: {
-  referenceId: Amity.Reaction['referenceId'];
-  referenceType: Amity.Reaction['referenceType'];
-  reactionName?: Amity.Reaction['reactionName'];
-  page?: Amity.Page;
-}): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page>> => {
+export const queryReactions = async (
+  query: Amity.QueryReactions,
+): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page<string>>> => {
   const client = getActiveClient();
   client.log('reaction/queryReactions', query);
 
   const { page = { limit: 10 }, ...params } = query ?? {};
 
-  const { data } = await client.http.get<{ results: Amity.ReactionPayload } & Amity.Pagination>(
-    `/api/v2/reactions`,
+  const { data } = await client.http.get<Amity.ReactionPayload & Amity.Pagination>(
+    `/api/v3/reactions`,
     {
       params: {
         ...params,
         options: {
-          token: toToken(page, 'skiplimit'),
+          token: toToken(page, 'afterbeforeraw'),
         },
       },
     },
   );
 
-  const { paging, results } = data;
-  const { reactions } = results;
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  ingestInCache({ ...payload, reactions: reactions[0].reactors });
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: reactions, prevPage, nextPage };
 };

package/src/reaction/events/index.ts

@@ -1 +1,5 @@
+export * from './onReactionAdded';
 export * from './onReactionRemoved';
+
+export * from './onReactorAdded';
+export * from './onReactorRemoved';