@amityco/ts-sdk 0.0.1-e32b438.0 → 0.0.1-e556efe.0

package/src/post/observers/livePosts.ts

@@ -0,0 +1,170 @@
+/* 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,
+} 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('For using Live Collection feature you need to enable Cache!');
+  }
+
+  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, userPosts } from '~/utils/tests';
+import { pushToCache, enableCache, disableCache } from '~/cache/api';
+
+import { getPost } from '~/post/api';
+
+describe('post/api', () => {
+  const post = { postId: userPosts.page1[0] };
+  const post2 = { postId: userPosts.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, userPosts } from '~/utils/tests';
+
+describe('post/api', () => {
+  test('should return a post query', async () => {
+    const returnValue = [{ postId: userPosts.page1[0] }];
+
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        posts: returnValue,
+        paging: {},
+      },
+    });
+
+    const data = await queryPosts({
+      targetId: userPosts.targetId,
+      targetType: userPosts.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';

package/src/reaction/events/onReactorAdded.ts

@@ -0,0 +1,80 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onReactorAdded } from '@amityco/ts-sdk'
+ * const dispose = onReactorAdded('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been added
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorAdded = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (payload: Amity.MessagePayload) => {
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, userDisplayName, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'add') return;
+
+      ingestInCache(payload);
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(client, 'reaction/onReactorAdded', 'v3.message.didUpdate', filter);
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.PostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.addReaction', 'post.addReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.addReaction', 'comment.addReaction', filter);
+};

package/src/reaction/events/onReactorRemoved.ts

@@ -0,0 +1,85 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onReactorRemoved } from '@amityco/ts-sdk'
+ * const dispose = onReactorRemoved('post', postId, reactor => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Reactor} has been removed
+ *
+ * @param {@link Amity.ReactableType} referenceType
+ * @param {string} referenceId
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Events
+ * */
+export const onReactorRemoved = (
+  referenceType: Amity.ReactableType,
+  referenceId: Amity.Reaction['referenceId'],
+  callback: Amity.Listener<Amity.Reactor>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const callbackWrapper = (
+    referenceType_: Amity.ReactableType,
+    referenceId_: Amity.Reaction['referenceId'],
+    reaction: Amity.Reactor,
+  ) => {
+    if (referenceType_ === referenceType && referenceId_ === referenceId) {
+      callback(reaction);
+    }
+  };
+
+  if (referenceType === 'message') {
+    const filter = (payload: Amity.MessagePayload) => {
+      if (!payload.messages[0].latestReaction) return;
+
+      const { eventName, referenceId, referenceType, ...reactor } =
+        payload.messages[0].latestReaction;
+
+      if (eventName !== 'remove') return;
+
+      ingestInCache(payload);
+      ingestInCache({ reactions: [reactor as Amity.Reactor] });
+
+      callbackWrapper('message', payload.messages[0].messageId, reactor);
+    };
+
+    return createEventSubscriber(
+      client,
+      'reaction/onReactorRemoved',
+      'v3.message.didUpdate',
+      filter,
+    );
+  }
+
+  if (referenceType === 'post') {
+    const filter = (payload: Amity.PostPayload & { reactor: Amity.Reactor }) => {
+      const { reactor, ...rest } = payload;
+
+      ingestInCache(rest as Amity.PostPayload);
+      ingestInCache({ reactions: [reactor] });
+
+      callbackWrapper('post', payload.posts[0].postId, reactor);
+    };
+
+    return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
+  }
+
+  const filter = (payload: Amity.CommentPayload & { reactor: Amity.Reactor }) => {
+    const { reactor, ...rest } = payload;
+
+    ingestInCache(rest as Amity.CommentPayload);
+    ingestInCache({ reactions: [reactor] });
+
+    callbackWrapper('comment', payload.comments[0].commentId, reactor);
+  };
+
+  return createEventSubscriber(client, 'comment.removeReaction', 'comment.removeReaction', filter);
+};

package/src/reaction/observers/index.ts

@@ -0,0 +1 @@
+export * from './liveReactions';

package/src/reaction/observers/liveReactions.ts

@@ -0,0 +1,142 @@
+/* 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 } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import { onReactorAdded, onReactorRemoved } from '../events';
+import { queryReactions } from '../api';
+
+/**
+ * ```js
+ * import { liveReactions } from '@amityco/ts-sdk'
+ *
+ * let reactions = []
+ * const unsub = liveReactions({
+ *   referenceId: Amity.Reaction['referenceId'],
+ *   referenceType: Amity.Reaction['referenceType'],
+ * }, response => merge(reactions, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId 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 Reactions Live Collection
+ */
+export const liveReactions = (
+  params: Amity.ReactionLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveReactions(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 = [
+    'reaction',
+    'collection',
+    { referenceId: params.referenceId, referenceType: params.referenceType },
+  ];
+
+  const responder = (data: Amity.ReactionLiveCollectionCache) => {
+    const reactions: Amity.Reactor[] =
+      data.data
+        .map(reactorId => pullFromCache<Amity.Reactor>(['reaction', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: reactions,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (reaction: Amity.Reactor, action: Amity.ReactionActionType) => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    if (action === 'onAdded') {
+      collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+    } else if (action === 'onRemoved') {
+      collection.data = collection.data.filter(p => p !== reaction.reactionId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+
+    const reactions = collection?.data ?? [];
+
+    if (reactions.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryReactions, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: reactions,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onAdded'),
+    ),
+    onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction =>
+      realtimeRouter(reaction, 'onRemoved'),
+    ),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/utils/constants.ts

@@ -0,0 +1,2 @@
+export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';

package/src/utils/tests/client.ts

@@ -0,0 +1,5 @@
+import { createClient } from '~/client/api';
+
+const client = createClient('key', 'sg');
+
+export default client;

package/src/utils/tests/dummy.ts

@@ -0,0 +1,7 @@
+export const userPosts = {
+  targetId: 'userId',
+  targetType: 'user' as Amity.PostTargetType,
+  page1: ['postId11', 'postId12', 'postId13'],
+  page2: ['postId21', 'postId22', 'postId23'],
+  page3: ['postId31', 'postId32', 'postId33'],
+};