@amityco/ts-sdk 0.0.1-beta.30 → 0.0.1-beta.32

package/src/message/events/onMessageFetched.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onMessageFetched } from '@amityco/ts-sdk'
+ * const dispose = onMessageFetched(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Message Events
+ */
+export const onMessageFetched = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.MessagePayload) => {
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'message/onMessageFetched', 'v3.message.didFetch', filter);
+};

package/src/message/observers/index.ts

@@ -1,3 +1,4 @@
+export { liveMessage } from './liveMessage';
+export { liveMessages } from './liveMessages';
 export { observeMessage } from './observeMessage';
 export { observeMessages } from './observeMessages';
-export { liveMessages } from './liveMessages';

package/src/message/observers/liveMessage.ts

@@ -0,0 +1,100 @@
+import { ASCApiError } from '~/core/errors';
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+} from '~/utils/constants';
+
+import { getMessage } from '../api';
+import { onMessageUpdated, onMessageDeleted, onMessageFetched } from '../events';
+
+/**
+ * ```js
+ * import { liveMessage } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = liveMessage(messageId, response => merge(messages, response.data))
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Message}
+ *
+ * @param messageId the ID of the message to observe
+ * @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 Message Live Object
+ */
+export const liveMessage = (
+  messageId: Amity.Message['messageId'],
+  callback: Amity.LiveObjectCallback<Amity.Message>,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+  let message: Amity.Message;
+  let isUnsyncedObject = false;
+
+  if (!cache) {
+    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveMessage(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveObject<Amity.Message>) => {
+    // we check updatedAt to see if the current snapshot is new so
+    // we won't send old data back, only fresh new data
+    if (message && data.data?.updatedAt === message?.updatedAt && data.origin !== 'server') return;
+
+    callback(data);
+    message = data.data;
+  };
+
+  const realtimeRouter = (message: Amity.Message, action: Amity.MessageActionType) => {
+    dispatcher({ loading: false, data: message, origin: 'event' });
+  };
+
+  const onFetch = () => {
+    const query = createQuery(getMessage, messageId, true);
+
+    runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedObject = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedObject) {
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        // Terminate observe functionality on error
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(
+    onMessageFetched(message => realtimeRouter(message, 'onFetch')),
+    onMessageUpdated(message => realtimeRouter(message, 'onUpdate')),
+    onMessageDeleted(message => realtimeRouter(message, 'onDelete')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveMessage(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/message/observers/liveMessages.ts

@@ -10,7 +10,7 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 
-import { onMessageCreated, onMessageDeleted, onMessageUpdated } from '../events';
+import { onMessageCreated, onMessageDeleted, onMessageUpdated, onMessageFetched } from '../events';
 import { queryMessages } from '../api';
 
 /**
@@ -126,6 +126,8 @@ export const liveMessages = (
   };
 
   disposers.push(
+    onMessageFetched(message => realtimeRouter(message, 'onFetch')),
+
     onMessageCreated(message => realtimeRouter(message, 'onCreate')),
     onMessageDeleted(message => realtimeRouter(message, 'onDelete')),
 

package/src/message/observers/observeMessage.ts

@@ -34,6 +34,10 @@ export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete'
   const timestamp = Date.now();
   log(`observeMessage(tmpid: ${timestamp}) > listen`);
 
+  console.log(
+    'observeMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+  );
+
   // wrapper function to make sure
   const router = (result: Amity.Snapshot<Amity.Message>, action: Events[number]) => {
     // filter function

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

@@ -0,0 +1,248 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+} from '~/utils/constants';
+import { liveMessage } from '../../observers/liveMessage';
+import { createMessage } from '../../api';
+
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  messageQueryResponse,
+  message11 as defaultMessage,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: undefined as undefined | Amity.Message,
+  };
+};
+
+describe('liveMessage', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    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 liveMessage check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return message live object', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // 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 = defaultMessage;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return error on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should terminate updates on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+
+    const updatedAt = new Date(defaultMessage?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedMessage = {
+      ...defaultMessage,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('v3.message.didUpdate', { messages: [updatedMessage] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedMessage;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should not return updates on obtain once!', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+
+    const unsub = liveMessage(defaultMessage.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    unsub();
+
+    const updatedAt = new Date(defaultMessage?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedMessage = {
+      ...defaultMessage,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('v3.message.didUpdate', { messages: [updatedMessage] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedMessage;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events][] = [
+    ['it should return updated message on onFetch', 'v3.message.didFetch'],
+    ['it should return updated message on onUpdate', 'v3.message.didUpdate'],
+    ['it should return updated message on onDelete', 'v3.message.didDelete'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+
+    liveMessage(defaultMessage.messageId, callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    const updatedAt = new Date(defaultMessage?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedMessage = {
+      ...defaultMessage,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit(event, { messages: [updatedMessage] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedMessage;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should terminate updates for unsynced object', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn();
+    const snapshot = getSnapshot();
+    const data = { channelId: 'test', data: { text: 'text' } };
+
+    const message = createMessage.optimistically(data);
+
+    const error = new ASCApiError(
+      UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+      Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    liveMessage(message!.data.messageId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    snapshot.data = message!.data;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+});

package/src/message/{observers/tests → tests/observers}/liveMessages.test.ts

@@ -2,15 +2,15 @@ import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 
-import { liveMessages } from '../liveMessages';
-import { queryMessages } from '~/message/api';
+import { queryMessages } from '../../api';
+import { liveMessages } from '../../observers';
 
 import {
   client,
   connectClient,
   disconnectClient,
   messages,
-  message as defaultMessage,
+  message11 as defaultMessage,
 } from '~/utils/tests';
 
 describe('liveMessages', () => {
@@ -222,6 +222,32 @@ describe('liveMessages', () => {
     );
   });
 
+  test('it should add new message to collection onFetch', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit('v3.message.didFetch', { messages: [message] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
   test('it should add new message to collection onCreate', async () => {
     const newMessage = {
       ...message,

package/src/post/api/deletePost.ts

@@ -1,8 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
-import { getCommunity } from '~/community/api';
-import { dropFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
+import { upsertInCache } from '~/cache/api';
+import { getCommunity } from '~/community/api';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 import { getPost } from './getPost';
 
@@ -53,7 +54,7 @@ export const deletePost = async (
 
   if (permanent) {
     setTimeout(() => {
-      dropFromCache(['post', 'get', postId], true);
+      pushToTombstone('post', postId);
     }, 0);
   } else {
     upsertInCache(['post', 'get', postId], { isDeleted: true });

package/src/post/api/getPost.ts

@@ -1,7 +1,10 @@
 import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 /**
  * ```js
@@ -21,6 +24,8 @@ export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cache
   const client = getActiveClient();
   client.log('post/getPost', postId);
 
+  isInTombstone('post', postId);
+
   let data: Amity.PostPayload;
 
   try {
@@ -28,11 +33,10 @@ export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cache
     const response = await client.http.get<Amity.PostPayload>(
       `/api/v3/posts/${encodeURIComponent(postId)}`,
     );
-
     data = response.data;
   } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
-      dropFromCache(['post', 'get', postId], true);
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('post', postId);
     }
 
     throw error;

package/src/post/api/updatePost.ts

@@ -22,7 +22,12 @@ import { fireEvent } from '~/core/events';
  */
 export const updatePost = async (
   postId: Amity.Post['postId'],
-  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'>,
+  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'> & {
+    attachments?: {
+      type: 'image' | 'file' | 'video';
+      fileId: Amity.File['fileId'];
+    }[];
+  },
 ): Promise<Amity.Cached<Amity.Post>> => {
   const client = getActiveClient();
   client.log('user/updatePost', patch);

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

@@ -1,23 +1,122 @@
-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: {},
-      },
-    });
+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 = await queryPosts({
-      targetId: posts.targetId,
-      targetType: posts.targetType,
+    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,
     });
 
-    expect(data).toBeDefined();
-    expect(data?.data).toEqual(returnValue);
+    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

@@ -38,10 +38,7 @@ export const addReaction = async (
     reactionName,
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
-
-  return model.data.myReactions?.includes(reactionName) ?? false;
+  return true;
 };
 
 /**