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

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

@@ -1,19 +1,18 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
-import { client, message11 } from '~/utils/tests';
+import { client, generateRawMessage } from '~/utils/tests';
 
 import { getMessages } from '../getMessages';
-import { onMessageFetched } from '../../events';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import { convertFromRaw } from '../../utils';
 
-const messagesToGet = [
-  { ...message11, messageId: 'message11' },
-  { ...message11, messageId: 'message12' },
-];
-const messageIds = ['message11', 'message12'];
+const rawMessagesToGet = [generateRawMessage(), generateRawMessage({ messageId: 'message-id-2' })];
+const messagesToGet = rawMessagesToGet.map(convertFromRaw);
+const messageIds = messagesToGet.map(x => x.messageId);
 
 const getResolvedMessageValue = () => ({
   data: {
-    messages: messagesToGet,
+    messages: rawMessagesToGet,
     users: [],
     files: [],
   },

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

@@ -1,28 +1,29 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { client, message11 } from '~/utils/tests';
+import { client, generateRawMessage } from '~/utils/tests';
 
+import { convertFromRaw, convertQueryParams } from '../../utils';
 import { queryMessages } from '../queryMessages';
-import { onMessageFetched } from '../../events';
+import { onMessageFetched } from '../../events/onMessageFetched';
 
-const messagesToQuery = [
-  { ...message11, messageId: 'message11' },
-  { ...message11, messageId: 'message12' },
+const rawMessagesToQuery = [
+  generateRawMessage(),
+  generateRawMessage({ messageId: 'message-id-2' }),
 ];
-const messageIds = ['message11', 'message12'];
-const queryCriteriaWithoutPage = { channelId: messagesToQuery[0].channelId };
-const pagingCriteria = { limit: 10 };
-const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
-const pagingToken = {
+const messagesToQuery = rawMessagesToQuery.map(convertFromRaw);
+const messageIds = messagesToQuery.map(x => x.messageId);
+const queryCriteriaWithoutPage = { subChannelId: messagesToQuery[0].subChannelId };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: { limit: 10 } };
+const paging = {
   previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
   next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
 };
 
 const getResolvedMessageValue = () => ({
   data: {
-    messages: messagesToQuery,
+    messages: rawMessagesToQuery,
     files: [],
     users: [],
-    paging: pagingToken,
+    paging,
   },
 });
 
@@ -45,15 +46,11 @@ describe('queryMessages', () => {
 
     await queryMessages(queryCriteria);
 
-    const recieved = pullFromCache([
-      'message',
-      'query',
-      { ...queryCriteriaWithoutPage, options: pagingCriteria },
-    ])?.data;
+    const recieved = pullFromCache(['message', 'query', convertQueryParams(queryCriteria)])?.data;
 
     expect(recieved).toEqual({
       messages: messageIds,
-      paging: pagingToken,
+      paging,
     });
 
     disableCache();
@@ -86,9 +83,9 @@ describe('queryMessages.locally', () => {
   test('should return cached messages', () => {
     messagesToQuery.forEach(message => pushToCache(['message', 'get', message.messageId], message));
 
-    pushToCache(['message', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+    pushToCache(['message', 'query', convertQueryParams(queryCriteria)], {
       messages: messageIds,
-      paging: pagingToken,
+      paging,
     });
 
     expect(queryMessages.locally(queryCriteria)).toEqual(
@@ -101,15 +98,15 @@ describe('queryMessages.locally', () => {
   });
 
   test(`shouldn't return if individual message cache not exist`, () => {
-    pushToCache(['message', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+    pushToCache(['message', 'query', convertQueryParams(queryCriteria)], {
       messages: messageIds,
-      paging: pagingToken,
+      paging,
     });
 
     expect(queryMessages.locally(queryCriteria)).toBeUndefined();
   });
 
   test('it should return undefined if message not in cache', () => {
-    expect(queryMessages.locally({ channelId: 'non-existent' })).toBeUndefined();
+    expect(queryMessages.locally({ subChannelId: 'non-existent' })).toBeUndefined();
   });
 });

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

@@ -1,18 +1,20 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
-import { client, message11 } from '~/utils/tests';
+import { client, generateRawMessage } from '~/utils/tests';
 
 import { updateMessage } from '../updateMessage';
 import { onMessageUpdated } from '../../events';
+import { convertFromRaw } from '../../utils';
 
-const messageToUpdate = message11;
+const rawMessageToUpdate = generateRawMessage();
+const messageToUpdate = convertFromRaw(rawMessageToUpdate);
 const { messageId } = messageToUpdate;
 const patch = { data: { text: 'hello world' } };
-const updatedMessage = { ...messageToUpdate, ...patch };
-const { updatedAt, ...updatedMessageWithoutTS } = updatedMessage;
+const rawUpdatedMessage = { ...rawMessageToUpdate, ...patch };
+const updatedMessage = convertFromRaw(rawUpdatedMessage);
 
 const getResolvedMessageValue = () => ({
   data: {
-    messages: [updatedMessage],
+    messages: [rawUpdatedMessage],
     users: [],
     files: [],
   },
@@ -24,9 +26,7 @@ describe('updateMessage', () => {
 
     const recieved = updateMessage(messageId, patch);
 
-    await expect(recieved).resolves.toEqual(
-      expect.objectContaining({ data: updatedMessageWithoutTS }),
-    );
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedMessage }));
   });
 
   test('should throw an error if request fails', async () => {
@@ -57,9 +57,7 @@ describe('updateMessage', () => {
 
     await updateMessage(messageId, patch);
 
-    await expect(callbackPromise).resolves.toEqual(
-      expect.objectContaining(updatedMessageWithoutTS),
-    );
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(updatedMessage));
   });
 });
 
@@ -88,7 +86,10 @@ describe('updateMessage.optimistically', () => {
     updateMessage.optimistically(messageId, patch);
 
     await expect(callbackPromise).resolves.toEqual(
-      expect.objectContaining(updatedMessageWithoutTS),
+      expect.objectContaining({
+        ...updatedMessage,
+        updatedAt: expect.anything(),
+      }),
     );
   });
 

package/src/message/api/updateMessage.ts

@@ -3,6 +3,7 @@ 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';
 
 /**
  * ```js
@@ -26,19 +27,21 @@ export const updateMessage = async (
   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.RawMessagePayload>(
+      `/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('v3.message.didUpdate', { messages });
+  fireEvent('local.message.updated', { messages });
 
   return {
     data: messages.find(message => message.messageId === messageId)!,
@@ -49,7 +52,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' }
  * })
  * ```
@@ -67,7 +70,7 @@ updateMessage.optimistically = (
   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;
 
@@ -83,7 +86,7 @@ updateMessage.optimistically = (
   };
 
   upsertInCache(['message', 'get', messageId], updated, { cachedAt });
-  fireEvent('v3.message.didUpdate', { messages: [updated] });
+  fireEvent('local.message.updated', { messages: [updated] });
 
   return {
     data: updated,

package/src/message/events/index.ts

@@ -1,4 +1,10 @@
 export * from './onMessageCreated';
 export * from './onMessageUpdated';
 export * from './onMessageDeleted';
-export * from './onMessageFetched';
+
+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.RawMessagePayload) => {
+    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.RawMessagePayload) => {
+    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

@@ -26,5 +26,5 @@ export const onMessageFetched = (callback: Amity.Listener<Amity.Message>): Amity
     callback(payload.messages[0]);
   };
 
-  return createEventSubscriber(client, 'message/onMessageFetched', 'v3.message.didFetch', filter);
+  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.RawMessagePayload) => {
+    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.RawMessagePayload) => {
+    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.RawMessagePayload) => {
+    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.RawMessagePayload) => {
+    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.RawMessagePayload) => {
+    const payload = prepareMessagePayload(rawPayload);
+
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
+
+  return createEventSubscriber(client, 'onMessageUnflagged', 'message.unflagged', filter);
+};

package/src/message/events/onMessageUpdated.ts

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