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

package/src/post/tests/api/queryPosts.test.ts

@@ -0,0 +1,122 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { client, postQueryResponse } from '~/utils/tests';
+
+import { queryPosts } from '../../api/queryPosts';
+
+const params = { targetType: 'user', targetId: 'test' } as Amity.QueryPosts;
+
+describe('queryPosts', () => {
+  test('it should return posts', async () => {
+    const { posts: expected } = postQueryResponse.data;
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data } = await queryPosts(params);
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryPosts(params)).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data: expected } = await queryPosts(params);
+    const { data: received } = queryPosts.locally(params)!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('queryPosts.locally', () => {
+  const cacheKey = ['post', 'query', { ...params, options: { limit: 10 } } as Amity.Serializable];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts: expected, paging } = data;
+
+    ingestInCache(data as Amity.PostPayload);
+
+    pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
+
+    const { data: received } = queryPosts.locally(params)!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts, paging } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      posts: [data.posts[0]],
+    } as Amity.PostPayload);
+
+    pushToCache(cacheKey, {
+      posts: posts.map(getResolver('post')),
+      paging,
+    });
+
+    const received = queryPosts.locally(params)!;
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  // added because of comment above cache key in queryPosts
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts: expected, paging } = data;
+
+    ingestInCache(data as Amity.PostPayload);
+
+    pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
+
+    const { data: received } = queryPosts.locally(params)!;
+    const received2 = queryPosts.locally({ ...params, tags: ['tag1'] })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const received = queryPosts.locally(params);
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryPosts.locally(params)).toBeUndefined();
+  });
+});

package/src/reaction/api/addReaction.ts

@@ -1,8 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils';
 
 /**
  * ```js
@@ -38,10 +39,18 @@ export const addReaction = async (
     reactionName,
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
+  if (client.cache) {
+    const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  return model.data.myReactions?.includes(reactionName) ?? false;
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
 };
 
 /**
@@ -91,7 +100,9 @@ addReaction.optimistically = (
     },
   } as Amity.Model[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
   dispatchReactable(referenceType, reaction);
 

package/src/reaction/api/index.ts

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

package/src/reaction/api/queryReactions.ts

@@ -0,0 +1,52 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toToken, toPageRaw } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryReactions } from '@amityco/ts-sdk'
+ * const { data: reactions, prevPage, nextPage } = await queryReactions({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ReactionQuery} 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.ReactionQuery, 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,
+        options: {
+          token: toToken(page, 'afterbeforeraw'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
+
+  ingestInCache({ ...payload, reactions: reactions[0].reactors });
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
+
+  return { data: reactions, prevPage, nextPage };
+};

package/src/reaction/api/removeReaction.ts

@@ -1,8 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils';
 
 /**
  * ```js
@@ -36,10 +37,18 @@ export const removeReaction = async (
     data: { referenceId, referenceType, reactionName },
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
+  if (client.cache) {
+    const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  return !model.data.myReactions?.includes(reactionName) ?? false;
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
 };
 
 /**
@@ -89,7 +98,9 @@ removeReaction.optimistically = (
     },
   } as Amity.Model[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
   dispatchReactable(referenceType, reaction);
 

package/src/reaction/api/tests/addReaction.test.ts

@@ -0,0 +1,73 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { onMessageUpdated } from '~/message/events';
+import { addReaction } from '~/reaction/api';
+
+import { client, message11 as message, pause } from '~/utils/tests';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+
+const cacheKey = ['message', 'get', message.messageId];
+
+describe('addReaction', () => {
+  test('it should add a reaction', async () => {
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('addReaction > optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(addReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = addReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.data).toMatchObject({
+      myReactions: ['like'],
+      reactions: { like: 1 },
+      reactionsCount: 1,
+    });
+    await pause();
+    expect(callback).toBeCalledTimes(1);
+  });
+
+  test('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
+
+    const success = addReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+  });
+});

package/src/reaction/api/tests/removeReaction.test.ts

@@ -0,0 +1,79 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { onMessageUpdated } from '~/message/events';
+import { removeReaction } from '~/reaction/api';
+
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { client, message11, pause } from '~/utils/tests';
+
+const message = {
+  ...message11,
+  myReactions: ['like'],
+  reactions: { like: 1 },
+  reactionsCount: 1,
+};
+const cacheKey = ['message', 'get', message.messageId];
+
+describe('removeReaction', () => {
+  test('it should remove a reaction', async () => {
+    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('removeReaction > optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(removeReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically remove a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = removeReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.data).toMatchObject({
+      myReactions: [],
+      reactions: { like: 0 },
+      reactionsCount: 0,
+    });
+    await pause();
+    expect(callback).toBeCalledTimes(1);
+  });
+
+  test('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
+
+    const success = removeReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+  });
+});

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/onReactionAdded.ts

@@ -5,6 +5,7 @@ import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { onPostReactionAdded } from '~/post/events';
 import { onCommentReactionAdded } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -34,10 +35,15 @@ export const onReactionAdded = (
     }
   };
 
+  /*
+   * Important: Want to point out that reference type will never be 'message'
+   * for onReactionAdded
+   */
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',
@@ -52,12 +58,7 @@ export const onReactionAdded = (
       }
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactionAdded',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactionAdded', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/events/onReactionRemoved.ts

@@ -5,6 +5,7 @@ import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { onPostReactionRemoved } from '~/post/events';
 import { onCommentReactionRemoved } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -37,7 +38,8 @@ export const onReactionRemoved = (
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',
@@ -52,12 +54,7 @@ export const onReactionRemoved = (
       }
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactionRemoved',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactionRemoved', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/events/onReactorAdded.ts

@@ -0,0 +1,82 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
+
+/**
+ * ```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 = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
+      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', 'message.updated', 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,82 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
+
+/**
+ * ```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 = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
+      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', 'message.updated', 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';