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

package/src/message/observers/liveMessage.ts

@@ -2,27 +2,39 @@ 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,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
 } from '~/utils/constants';
-
+import { hasUpdates } from '~/core/model';
 import { getMessage } from '../api';
-import { onMessageUpdated, onMessageDeleted, onMessageFetched } from '../events';
+import {
+  onMessageUpdated,
+  onMessageDeleted,
+  onMessageFlagged,
+  onMessageUnflagged,
+  onMessageFlagCleared,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+} from '../events';
+import { onMessageFetched } from '../events/onMessageFetched';
 
 /**
  * ```js
- * import { liveMessage } from '@amityco/ts-sdk'
+ * import { liveMessage } from '@amityco/ts-sdk';
+ *
+ * let message;
  *
- * let messages = []
- * const unsub = liveMessage(messageId, response => merge(messages, response.data))
+ * const unsubscribe = liveMessage(messageId, response => {
+ *   message = 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
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
  *
  * @category Message Live Object
  */
@@ -31,29 +43,32 @@ export const liveMessage = (
   callback: Amity.LiveObjectCallback<Amity.Message>,
 ): Amity.Unsubscriber => {
   const { log, cache } = getActiveClient();
-  let message: Amity.Message;
-  let isUnsyncedObject = false;
+  const timestamp = Date.now();
+  log(`liveMessage(tmpid: ${timestamp}) > listen`);
 
   if (!cache) {
     console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
   }
 
-  const timestamp = Date.now();
-  log(`liveMessage(tmpid: ${timestamp}) > listen`);
-
+  let message: Amity.Message;
+  let isUnsyncedObject = false;
   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;
+    callback(data);
   };
 
-  const realtimeRouter = (message: Amity.Message, action: Amity.MessageActionType) => {
-    dispatcher({ loading: false, data: message, origin: 'event' });
+  const realtimeRouter = (eventMessage: Amity.Message) => {
+    if (messageId !== eventMessage.messageId) {
+      return;
+    }
+
+    if (message && !hasUpdates(message, eventMessage)) {
+      return;
+    }
+
+    dispatcher({ loading: false, data: eventMessage, origin: 'event' });
   };
 
   const onFetch = () => {
@@ -79,16 +94,20 @@ export const liveMessage = (
       }
 
       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')),
+    onMessageFetched(realtimeRouter),
+    onMessageUpdated(realtimeRouter),
+    onMessageDeleted(realtimeRouter),
+    onMessageFlagged(realtimeRouter),
+    onMessageUnflagged(realtimeRouter),
+    onMessageFlagCleared(realtimeRouter),
+    onMessageReactionAdded(realtimeRouter),
+    onMessageReactionRemoved(realtimeRouter),
   );
 
   onFetch();

package/src/message/observers/liveMessages.ts

@@ -10,22 +10,33 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 
-import { onMessageCreated, onMessageDeleted, onMessageUpdated, onMessageFetched } from '../events';
+import {
+  onMessageCreated,
+  onMessageDeleted,
+  onMessageUpdated,
+  onMessageFlagged,
+  onMessageUnflagged,
+  onMessageFlagCleared,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+} from '../events';
+import { onMessageFetched } from '../events/onMessageFetched';
 import { queryMessages } from '../api';
 
 /**
  * ```js
- * import { liveMessages } from '@amityco/ts-sdk'
+ * import { liveMessages } from '@amityco/ts-sdk';
+ *
+ * let messages = [];
  *
- * let messages = []
- * const unsub = liveMessages({
- *   channelId: Amity.Channel['channelId'];
- * }, response => merge(messages, response.data))
+ * const unsubscribe = liveMessages({
+ *   subChannelId: Amity.SubChannel['subChannelId'];
+ * }, 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 params for querying messages from a sub 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
  *
@@ -51,7 +62,7 @@ export const liveMessages = (
   const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
 
   const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['message', 'collection', { channelId: params.channelId }];
+  const cacheKey = ['message', 'collection', { subChannelId: params.subChannelId }];
 
   const responder = (data: Amity.MessageLiveCollectionCache) => {
     let messages: Amity.Message[] =
@@ -75,10 +86,10 @@ export const liveMessages = (
     });
   };
 
-  const realtimeRouter = (message: Amity.Message, action: Amity.MessageActionType) => {
+  const realtimeRouter = (action: Amity.MessageActionType) => (message: Amity.Message) => {
     const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
 
-    if (params.channelId !== message.channelId || !collection) return;
+    if (params.subChannelId !== message.subChannelId || !collection) return;
 
     if (action === 'onCreate') {
       collection.data = [...new Set([message.messageId, ...collection.data])];
@@ -126,12 +137,15 @@ export const liveMessages = (
   };
 
   disposers.push(
-    onMessageFetched(message => realtimeRouter(message, 'onFetch')),
-
-    onMessageCreated(message => realtimeRouter(message, 'onCreate')),
-    onMessageDeleted(message => realtimeRouter(message, 'onDelete')),
-
-    onMessageUpdated(message => realtimeRouter(message, 'onUpdate')),
+    onMessageFetched(realtimeRouter('onFetch')),
+    onMessageCreated(realtimeRouter('onCreate')),
+    onMessageUpdated(realtimeRouter('onUpdate')),
+    onMessageDeleted(realtimeRouter('onDelete')),
+    onMessageFlagged(realtimeRouter('onFlagged')),
+    onMessageUnflagged(realtimeRouter('onUnflagged')),
+    onMessageFlagCleared(realtimeRouter('onFlagCleared')),
+    onMessageReactionAdded(realtimeRouter('onReactionAdded')),
+    onMessageReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
   onFetch();

package/src/message/observers/observeMessage.ts

@@ -11,6 +11,7 @@ import { onMessageUpdated, onMessageDeleted } from '../events';
  * import { observeMessage } from '@amityco/ts-sdk'
  *
  * let message = {}
+ *
  * const unsub = observeMessage(messageId, updated => message = updated)
  * ```
  *

package/src/message/observers/observeMessages.ts

@@ -7,19 +7,20 @@ import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '../events'
  * import { observeMessages } from '@amityco/ts-sdk'
  *
  * let messages = []
- * const unsub = observeMessages(channelId, message => merge(messages, message))
+ *
+ * const unsubscribe = observeMessages(channelId, message => merge(messages, message))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
+ * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.SubChannel} object
  *
- * @param channelId the ID of the channel where to observe the messages
+ * @param subChannelId 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
  *
  * @category Message Observer
  */
 export const observeMessages = (
-  channelId: Amity.Channel['channelId'],
+  subChannelId: Amity.SubChannel['subChannelId'],
   callback: Amity.ObjectListener<
     Amity.Snapshot<Amity.Message>,
     ['onCreate', 'onUpdate', 'onDelete']
@@ -36,7 +37,7 @@ export const observeMessages = (
     message: Amity.Snapshot<Amity.Message>,
     action: 'onCreate' | 'onUpdate' | 'onDelete',
   ) => {
-    if (message.data?.channelId !== channelId) return;
+    if (message.data?.subChannelId !== subChannelId) return;
 
     if (callback instanceof Function) return callback(message);
 

package/src/message/tests/events.test.ts

@@ -0,0 +1,53 @@
+import { client, generateRawMessage } from '~/utils/tests';
+import { convertFromRaw } from '~/message/utils';
+import {
+  onMessageCreated,
+  onMessageUpdated,
+  onMessageDeleted,
+  onMessageFlagged,
+  onMessageUnflagged,
+  onMessageFlagCleared,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+} from '../events';
+
+describe('Message Events', () => {
+  const rawMessage = generateRawMessage();
+  const message = convertFromRaw(rawMessage);
+
+  const cases: Array<
+    [(callback: Amity.Listener<Amity.Message>) => Amity.Unsubscriber, keyof Amity.MqttMessageEvents]
+  > = [
+    [onMessageCreated, 'message.created'],
+    [onMessageUpdated, 'message.updated'],
+    [onMessageDeleted, 'message.deleted'],
+    [onMessageFlagged, 'message.flagged'],
+    [onMessageUnflagged, 'message.unflagged'],
+    [onMessageFlagCleared, 'message.flagCleared'],
+    [onMessageReactionAdded, 'message.reactionAdded'],
+    [onMessageReactionRemoved, 'message.reactionRemoved'],
+  ];
+
+  cases.forEach(([onEvent, event]) => {
+    test(`should call '${onEvent.name}' callback if '${event}' event is dispatched`, () => {
+      const callback = jest.fn();
+      const unsubscribe = onEvent(callback);
+      client.emitter.emit(event, { messages: [rawMessage] });
+
+      unsubscribe();
+
+      expect(callback).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith(message);
+    });
+
+    test(`should not call '${onEvent.name}' callback if we have already unsubscribed`, () => {
+      const callback = jest.fn();
+      const unsubscribe = onEvent(callback);
+
+      unsubscribe();
+      client.emitter.emit(event, { messages: [rawMessage] });
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -4,17 +4,17 @@ import {
   LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
   UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
 } from '~/utils/constants';
+import { pause, client, connectClient, disconnectClient, generateRawMessage } from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+import { convertFromRaw } from '../../utils';
 import { liveMessage } from '../../observers/liveMessage';
 import { createMessage } from '../../api';
 
-import {
-  pause,
-  client,
-  connectClient,
-  disconnectClient,
-  messageQueryResponse,
-  message11 as defaultMessage,
-} from '~/utils/tests';
+const rawMessage = generateRawMessage();
+const message = convertFromRaw(rawMessage);
+const messageQueryResponseRaw = {
+  data: { messages: [rawMessage] },
+};
 
 const getSnapshot = () => {
   return {
@@ -33,9 +33,7 @@ describe('liveMessage', () => {
     await disconnectClient();
   });
 
-  beforeEach(async () => {
-    enableCache();
-  });
+  beforeEach(enableCache);
 
   afterEach(disableCache);
 
@@ -54,7 +52,7 @@ describe('liveMessage', () => {
     // call liveMessage check if mocked console get's called with the correct
     // message
     client.use();
-    liveMessage(defaultMessage.messageId, callback);
+    liveMessage(message.messageId, callback);
 
     expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
   });
@@ -64,9 +62,9 @@ describe('liveMessage', () => {
 
     // mock response of queryMessages and validate
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
 
-    liveMessage(defaultMessage.messageId, callback);
+    liveMessage(message.messageId, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -78,7 +76,7 @@ describe('liveMessage', () => {
     expect(callback).toHaveBeenCalledTimes(2);
 
     snapshot.loading = false;
-    snapshot.data = defaultMessage;
+    snapshot.data = message;
 
     expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
   });
@@ -95,7 +93,7 @@ describe('liveMessage', () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockRejectedValue(error);
 
-    liveMessage(defaultMessage.messageId, callback);
+    liveMessage(message.messageId, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -123,7 +121,7 @@ describe('liveMessage', () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockRejectedValue(error);
 
-    liveMessage(defaultMessage.messageId, callback);
+    liveMessage(message.messageId, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -138,14 +136,9 @@ describe('liveMessage', () => {
     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] });
+    const rawUpdatedMessage = { ...rawMessage, updatedAt: getFutureDate(rawMessage.updatedAt) };
+    const updatedMessage = convertFromRaw(rawUpdatedMessage);
+    client.emitter.emit('message.updated', { messages: [rawUpdatedMessage] });
 
     delete snapshot.error;
     snapshot.loading = false;
@@ -158,9 +151,9 @@ describe('liveMessage', () => {
 
     // mock response of queryMessages and validate
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
 
-    const unsub = liveMessage(defaultMessage.messageId, callback);
+    const unsub = liveMessage(message.messageId, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -173,14 +166,9 @@ describe('liveMessage', () => {
 
     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] });
+    const rawUpdatedMessage = { ...rawMessage, updatedAt: getFutureDate(rawMessage.updatedAt) };
+    const updatedMessage = convertFromRaw(rawUpdatedMessage);
+    client.emitter.emit('message.updated', { messages: [rawUpdatedMessage] });
 
     delete snapshot.error;
     snapshot.loading = false;
@@ -189,9 +177,14 @@ describe('liveMessage', () => {
   });
 
   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'],
+    ['it should return updated message on onFetch', 'local.message.fetched'],
+    ['it should return updated message on onUpdate', 'message.updated'],
+    ['it should return updated message on onDelete', 'message.deleted'],
+    ['it should return updated message on onFlagged', 'message.flagged'],
+    ['it should return updated message on onUnflagged', 'message.unflagged'],
+    ['it should return updated message on onFlagCleared', 'message.flagCleared'],
+    ['it should return updated message on onReactionAdded', 'message.reactionAdded'],
+    ['it should return updated message on onReactionRemoved', 'message.reactionRemoved'],
   ];
 
   test.each(events)('%s', async (test, event) => {
@@ -199,34 +192,38 @@ describe('liveMessage', () => {
 
     // mock response of queryMessages and validate
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponse);
+    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
 
-    liveMessage(defaultMessage.messageId, callback);
+    liveMessage(message.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(),
+    const rawUpdatedMessage = {
+      ...rawMessage,
+      data: { text: event },
+      updatedAt: getFutureDate(rawMessage.updatedAt),
     };
-    client.emitter.emit(event, { messages: [updatedMessage] });
+    const updatedMessage = convertFromRaw(rawUpdatedMessage);
+    if (event === 'local.message.fetched') {
+      client.emitter.emit('local.message.fetched', { messages: [updatedMessage] });
+    } else {
+      client.emitter.emit(event, { messages: [rawUpdatedMessage] });
+    }
+    await pause();
 
     delete snapshot.error;
     snapshot.loading = false;
     snapshot.data = updatedMessage;
-    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+    expect(callback.mock.calls[2][0]).toMatchObject(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 data = { subChannelId: 'test', data: { text: 'text' } };
 
     const message = createMessage.optimistically(data);