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

package/src/message/api/tests/updateMessage.test.ts

@@ -0,0 +1,101 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, generateRawMessage } from '~/utils/tests';
+
+import { updateMessage } from '../updateMessage';
+import { onMessageUpdated } from '../../events';
+import { convertFromRaw } from '../../utils';
+
+const rawMessageToUpdate = generateRawMessage();
+const messageToUpdate = convertFromRaw(rawMessageToUpdate);
+const { messageId } = messageToUpdate;
+const patch = { data: { text: 'hello world' } };
+const rawUpdatedMessage = { ...rawMessageToUpdate, ...patch };
+const updatedMessage = convertFromRaw(rawUpdatedMessage);
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [rawUpdatedMessage],
+    users: [],
+    files: [],
+  },
+});
+
+describe('updateMessage', () => {
+  test('should return updated message', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const recieved = updateMessage(messageId, patch);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedMessage }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(updateMessage(messageId, patch)).rejects.toThrow('error');
+  });
+
+  test('should update cache after updated messages', async () => {
+    enableCache();
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await updateMessage(messageId, patch);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', messageId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(patch));
+
+    disableCache();
+  });
+
+  test('should fire event `onMessageUpdated`', async () => {
+    let dispose;
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageUpdated(resolve);
+    }).finally(dispose);
+
+    await updateMessage(messageId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(updatedMessage));
+  });
+});
+
+describe('updateMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should update cache after updated message', () => {
+    pushToCache(['message', 'get', messageId], messageToUpdate);
+
+    updateMessage.optimistically(messageId, patch);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', messageId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(patch));
+  });
+
+  test('should fire event `onMessageUpdated`', async () => {
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageUpdated(data => {
+        resolve(data);
+      });
+    }).finally(dispose);
+
+    updateMessage.optimistically(messageId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining({
+        ...updatedMessage,
+        updatedAt: expect.anything(),
+      }),
+    );
+  });
+
+  test('should define object as unsynced object', () => {
+    pushToCache(['message', 'get', messageId], messageToUpdate);
+
+    expect(updateMessage.optimistically(messageId, patch)?.cachedAt).toBe(-1);
+  });
+});

package/src/message/api/updateMessage.ts

@@ -3,7 +3,11 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
+import { convertParams, convertResponseFromRaw } from '../utils';
 
+/* begin_public_function
+  id: message.edit
+*/
 /**
  * ```js
  * import { updateMessage } from '@amityco/ts-sdk'
@@ -23,21 +27,25 @@ import { fireEvent } from '~/core/events';
  */
 export const updateMessage = async (
   messageId: Amity.Message['messageId'],
-  patch: Patch<Amity.Message, 'data' | 'metadata' | 'mentionees'>,
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
-  client.log('user/updateMessage', patch);
+  client.log('message/updateMessage', patch);
 
-  const { data } = await client.http.put<Amity.MessagePayload>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
-    patch,
-  );
+  const { data } = await client.http
+    .put<Amity.MessagePayload>(
+      `/api/v5/messages/${encodeURIComponent(messageId)}`,
+      convertParams(patch),
+    )
+    .then(convertResponseFromRaw);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { messages } = data;
 
+  fireEvent('local.message.updated', { messages });
+
   return {
     data: messages.find(message => message.messageId === messageId)!,
     cachedAt,
@@ -47,7 +55,7 @@ export const updateMessage = async (
 /**
  * ```js
  * import { updateMessage } from '@amityco/ts-sdk'
- * const updated = updateMessage.locally('foobar', {
+ * const updated = updateMessage.optimistically('foobar', {
  *   data: { text: 'hello world' }
  * })
  * ```
@@ -62,10 +70,10 @@ export const updateMessage = async (
  */
 updateMessage.optimistically = (
   messageId: Amity.Message['messageId'],
-  patch: Patch<Amity.Message, 'data' | 'metadata' | 'mentionees'>,
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('user/updateMessage', patch);
+  client.log('message/updateMessage.optimistically', patch);
 
   if (!client.cache) return;
 
@@ -81,10 +89,11 @@ updateMessage.optimistically = (
   };
 
   upsertInCache(['message', 'get', messageId], updated, { cachedAt });
-  fireEvent('v3.message.didUpdate', { messages: [updated] });
+  fireEvent('local.message.updated', { messages: [updated] });
 
   return {
     data: updated,
     cachedAt,
   };
 };
+/* end_public_function */

package/src/message/events/index.ts

@@ -1,3 +1,10 @@
 export * from './onMessageCreated';
 export * from './onMessageUpdated';
 export * from './onMessageDeleted';
+
+export * from './onMessageFlagged';
+export * from './onMessageUnflagged';
+export * from './onMessageFlagCleared';
+
+export * from './onMessageReactionAdded';
+export * from './onMessageReactionRemoved';

package/src/message/events/onMessageCreated.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { hasMention } from '~/utils';
+import { prepareMessagePayload } from '../utils';
 
 /**
  * ```js
@@ -21,10 +24,54 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const onMessageCreated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.MessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+    const message = payload.messages[0];
+    const cached = pullFromCache<Amity.Channel>(['channel', 'get', message.channelId]);
+
+    if (cached && cached.data.defaultSubChannelId === message.subChannelId) {
+      let update: Amity.Channel;
+
+      // @ts-ignore
+      if (cached.data.localReading) {
+        update = {
+          ...cached.data,
+          localReadToSegment: message.channelSegment,
+          localLastMentionSegment: hasMention(message, client.userId!)
+            ? message.channelSegment
+            : cached.data.localLastMentionSegment,
+          messageCount: message.channelSegment,
+          lastActivity: message.createdAt,
+          updatedAt: message.createdAt,
+        };
+      } else {
+        update = {
+          ...cached.data,
+          defaultSubChannelHasUnreadMention:
+            hasMention(message, client.userId!) || cached.data.defaultSubChannelHasUnreadMention,
+          defaultSubChannelUnreadCount: message.channelSegment - cached.data.localReadToSegment,
+          lastActivity: message.createdAt,
+          messageCount: message.channelSegment,
+          updatedAt: message.createdAt,
+        };
+      }
+
+      pushToCache(['channel', 'get', message.channelId], update);
+      client.emitter.emit('local.channel.updated', { channels: [update] });
+    }
+
     ingestInCache(payload);
-    callback(payload.messages[0]);
+    callback(message);
   };
 
-  return createEventSubscriber(client, 'message/onMessageCreated', 'v3.message.didCreate', filter);
+  const disposers = [
+    createEventSubscriber(client, 'message/onMessageCreated', 'message.created', filter),
+    createEventSubscriber(client, 'local.message.created', 'local.message.created', payload =>
+      callback(payload.messages[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
 };

package/src/message/events/onMessageDeleted.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
 
 /**
  * ```js
@@ -21,10 +22,21 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.MessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+
     ingestInCache(payload);
     callback(payload.messages[0]);
   };
 
-  return createEventSubscriber(client, 'message/onMessageDeleted', 'v3.message.didDelete', filter);
+  const disposers = [
+    createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
+    createEventSubscriber(client, 'local.message.deleted', 'local.message.deleted', payload =>
+      callback(payload.messages[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
 };

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.Events['local.message.fetched']) => {
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'message/onMessageFetched', 'local.message.fetched', filter);
+};

package/src/message/events/onMessageFlagCleared.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onMessageFlagCleared(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.Message}
+ *
+ * @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 onMessageFlagCleared = (
+  callback: Amity.Listener<Amity.Message>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.MessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageFlagCleared', 'message.flagCleared', filter);
+};

package/src/message/events/onMessageFlagged.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageFlagged } from '@amityco/ts-sdk'
+ * const dispose = onMessageFlagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Message} has been flagged
+ *
+ * @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 onMessageFlagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.MessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageFlagged', 'message.flagged', filter);
+};

package/src/message/events/onMessageReactionAdded.ts

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

package/src/message/events/onMessageReactionRemoved.ts

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

package/src/message/events/onMessageUnflagged.ts

@@ -0,0 +1,32 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { onMessageUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onMessageUnflagged(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.Message}
+ *
+ * @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 onMessageUnflagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (rawPayload: Amity.MessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageUnflagged', 'message.unflagged', filter);
+};

package/src/message/events/onMessageUpdated.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayload } from '../utils';
 
 /**
  * ```js
@@ -21,10 +22,21 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.MessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+
     ingestInCache(payload);
     callback(payload.messages[0]);
   };
 
-  return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);
+  const disposers = [
+    createEventSubscriber(client, 'message/onMessageUpdated', 'message.updated', filter),
+    createEventSubscriber(client, 'local.message.updated', 'local.message.updated', payload =>
+      callback(payload.messages[0]),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
 };

package/src/message/observers/index.ts

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

package/src/message/observers/liveMessage.ts

@@ -0,0 +1,47 @@
+import { liveObject } from '~/utils/liveObject';
+import { getMessage } from '../api';
+import {
+  onMessageUpdated,
+  onMessageDeleted,
+  onMessageFlagged,
+  onMessageUnflagged,
+  onMessageFlagCleared,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+} from '../events';
+import { onMessageFetched } from '../events/onMessageFetched';
+
+/**
+ * ```js
+ * import { liveMessage } from '@amityco/ts-sdk';
+ *
+ * let message;
+ *
+ * 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 message
+ *
+ * @category Message Live Object
+ */
+export const liveMessage = (
+  messageId: Amity.Message['messageId'],
+  callback: Amity.LiveObjectCallback<Amity.Message>,
+): Amity.Unsubscriber => {
+  return liveObject(messageId, callback, 'messageId', getMessage, [
+    onMessageFetched,
+    onMessageUpdated,
+    onMessageDeleted,
+    onMessageFlagged,
+    onMessageUnflagged,
+    onMessageFlagCleared,
+    onMessageReactionAdded,
+    onMessageReactionRemoved,
+  ]);
+};