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

package/src/message/api/createMessage.ts

@@ -1,16 +1,26 @@
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
-
-import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
+import { convertParams, convertResponseFromRaw } from '../utils';
+
+// FIXME: temp solution
+let uniqueId: string | undefined;
 
 /**
  * ```js
- * import { createMessage } from '@amityco/ts-sdk'
- * const created = await createMessage({
- *   channelId: 'foobar',
- *   data: { text: 'hello world' }
- * })
+ * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk'
+ *
+ * const query = createQuery(createMessage, {
+ *   subChannelId: 'foobar',
+ *   data: { text: 'hello world' },
+ * });
+ *
+ * runQuery(query, ({ data: message, loading }) => {
+ *   console.log(message);
+ * });
  * ```
  *
  * Creates an {@link Amity.Message}
@@ -24,20 +34,34 @@ import { fireEvent } from '~/core/events';
 export const createMessage = async <T extends Amity.MessageContentType>(
   bundle: Pick<
     Amity.Message<T>,
-    'channelId' | 'parentId' | 'type' | 'data' | 'metadata' | 'mentionees'
-  >,
+    'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
+  > & {
+    data?: Amity.Message<T>['data'];
+    fileId?: Amity.File['fileId'];
+  },
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
-  client.log('user/createMessage', bundle);
+  client.log('message/createMessage', bundle);
 
-  const { data } = await client.http.post<Amity.MessagePayload>('/api/v3/messages', bundle);
+  const referenceId = uniqueId;
+  uniqueId = undefined;
+  const { data } = await client.http
+    .post<Amity.RawMessagePayload>('/api/v5/messages', {
+      ...convertParams(bundle),
+      referenceId,
+    })
+    .then(convertResponseFromRaw);
 
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-  // no need for event, fired by server
+  if (client.cache) {
+    dropFromCache(['message', 'get', referenceId]);
+    ingestInCache(data, { cachedAt });
+  }
 
   const { messages } = data;
 
+  fireEvent('local.message.created', { messages });
+
   return {
     data: messages[0],
     cachedAt,
@@ -47,6 +71,7 @@ export const createMessage = async <T extends Amity.MessageContentType>(
 /**
  * ```js
  * import { createMessage } from '@amityco/ts-sdk'
+ *
  * const created = createMessage.locally({
  *   channelId: 'foobar',
  *   data: { text: 'hello world' }
@@ -61,36 +86,65 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  * @category Message API
  */
 createMessage.optimistically = (
-  bundle: Pick<
-    Amity.Message,
-    'channelId' | 'parentId' | 'type' | 'data' | 'metadata' | 'mentionees'
-  >,
+  bundle: Parameters<typeof createMessage>[0],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('user/createMessage.locally', bundle);
 
   if (!client.cache) return;
 
-  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundle.channelId]);
+  /*
+   * when creating messages optimistically a messageId needs to be added by the
+   * client, created a new variable so as to allow backward compatibility of API
+   *
+   * Updated to handle client requirement to add messageId while uploading
+   * message with image. Temporary!
+   */
+  const localId = `LOCAL_${uuid()}`;
+  uniqueId = localId;
+  const bundleWithMessageId = { messageId: localId, uniqueId: localId, ...bundle };
+
+  // only log if cache is enabled
+  client.log('message/createMessage.optimistically', bundleWithMessageId);
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', bundle.subChannelId]);
 
-  upsertInCache(['channel', 'get', bundle.channelId], {
-    ...channel?.data,
-    messageCount: (channel?.data.messageCount ?? 0) + 1,
-  });
+  if (subChannel) {
+    upsertInCache(['subChannel', 'get', bundle.subChannelId], {
+      ...subChannel.data,
+      messageCount: subChannel.data.messageCount + 1,
+    });
+
+    if (subChannel.data.channelId === subChannel.data.subChannelId) {
+      const channel = pullFromCache<Amity.Channel>(['channel', 'get', subChannel.data.channelId]);
+
+      if (channel?.data) {
+        upsertInCache(['channel', 'get', subChannel.data.channelId], {
+          ...channel.data,
+          messageCount: (channel.data.messageCount ?? 0) + 1,
+        });
+      }
+    }
+  }
+
+  // as reused to update created and updated time, which should be the same
+  const createdTime = new Date().toISOString();
 
   const message = {
-    messageId: Math.random().toString(16),
-    userId: client.userId,
-    channelSegment: (channel?.data.messageCount ?? 0) + 1,
-    createdAt: new Date().toISOString(),
-    ...bundle,
+    creatorId: client.userId!,
+    channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
+    childrenNumber: 0,
+    createdAt: createdTime,
+    updatedAt: createdTime,
+    ...bundleWithMessageId,
   } as Amity.Message;
 
-  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
-  fireEvent('v3.message.didCreate', { messages: [message] });
+  const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
+
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt });
+  fireEvent('local.message.created', { messages: [message] });
 
   return {
+    cachedAt,
     data: message,
-    cachedAt: -1,
   };
 };

package/src/message/api/deleteMessage.ts

@@ -1,10 +1,9 @@
 import { getActiveClient } from '~/client/api';
-
-import { getMessage } from './getMessage';
-
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
+import { getMessage } from './getMessage';
+
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
@@ -13,7 +12,7 @@ import { fireEvent } from '~/core/events';
  *
  * Delete a {@link Amity.Message}
  *
- * @param The ID of the {@link Amity.Message} to delete
+ * @param messageId the ID of the {@link Amity.Message} to delete
  * @return A success boolean if the {@link Amity.Message} was deleted
  *
  * @category Message API
@@ -27,11 +26,12 @@ export const deleteMessage = async (
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
   );
 
   const deleted = await getMessage(messageId);
-  // no need for event, fired by server
+
+  fireEvent('local.message.deleted', { messages: [deleted.data] });
 
   return deleted.data;
 };
@@ -53,7 +53,7 @@ deleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('message/deleteMessage', messageId);
+  client.log('message/deleteMessage.optimistically', messageId);
 
   const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 
@@ -67,7 +67,7 @@ deleteMessage.optimistically = (
   };
 
   upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
-  fireEvent('v3.message.didDelete', { messages: [deleted] });
+  fireEvent('local.message.deleted', { messages: [deleted] });
 
   return {
     data: deleted,

package/src/message/api/getMessage.ts

@@ -1,8 +1,14 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 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';
+import { convertResponseFromRaw } from '../utils';
+
 /**
  * ```js
  * import { getMessage } from '@amityco/ts-sdk'
@@ -19,20 +25,43 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getMessage = async (
   messageId: Amity.Message['messageId'],
+  isLive = false,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
   client.log('message/getMessage', messageId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
-  );
+  if (!isLive) {
+    console.log(
+      'getMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+    );
+  }
+
+  isInTombstone('message', messageId);
+
+  let data: Amity.MessagePayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http
+      .get<Amity.RawMessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
+      .then(convertResponseFromRaw);
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('message', messageId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { messages } = data;
 
+  fireEvent('local.message.fetched', { messages });
+
   return {
     data: messages.find(message => message.messageId === messageId)!,
     cachedAt,

package/src/message/api/getMessages.ts

@@ -1,7 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertResponseFromRaw } from '../utils';
 
 /**
  * ```js
@@ -23,16 +25,21 @@ export const getMessages = async (
   const client = getActiveClient();
   client.log('message/getMessages', messageIds);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(`/api/v3/messages/list`, {
-    params: { messageIds },
-  });
+  const { data } = await client.http
+    .get<Amity.RawMessagePayload>(`/api/v5/messages/list`, {
+      params: { messageIds: messageIds.map(encodeURIComponent) },
+    })
+    .then(convertResponseFromRaw);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { messages });
+
   return {
-    data: data.messages,
+    data: messages,
     cachedAt,
   };
 };

package/src/message/api/queryMessages.ts

@@ -1,9 +1,11 @@
 import { getActiveClient } from '~/client/api';
 
-import { toPage, toToken } from '~/core/query';
+import { fireEvent } from '~/core/events';
+import { toPage } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+import { convertQueryParams, convertResponseFromRaw } from '../utils';
 
 /**
  * ```js
@@ -19,56 +21,38 @@ import { getResolver } from '~/core/model';
  * @category Message API
  * @async
  */
-export const queryMessages = async (query: {
-  channelId: Amity.Channel['channelId'];
-  type?: Amity.MessageContentType;
-  parentId?: Amity.Message['parentId'];
-  filterByParentId?: boolean;
-  isDeleted?: boolean;
-  tags?: Amity.Taggable['tags'];
-  excludeTags?: Amity.Taggable['tags'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
+export const queryMessages = async (
+  query: Amity.QueryMessages,
+): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 
-  const { page = { limit: 10 }, ...params } = query;
+  const params = convertQueryParams(query);
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // API-FIX: pagination should not be indexed on channelSegment (3)
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
-  const { data } = await client.http.get<Amity.MessagePayload & Amity.Pagination>(
-    `/api/v3/messages`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'afterbefore'),
-        },
-      },
-    },
-  );
+  const response = await client.http
+    .get<Amity.RawMessagePayload & Amity.Pagination>(`/api/v5/messages`, { params })
+    .then(convertResponseFromRaw);
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, messages } = unwrapPayload(data)
-
-  const { paging, ...payload } = data;
-  const { messages } = payload;
+  const { paging, ...data } = response.data;
+  const { messages } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.MessagePayload, { cachedAt });
+    ingestInCache(data as Amity.MessagePayload, { cachedAt });
 
-    const cacheKey = [
-      'message',
-      'query',
-      { ...params, options: { ...page } } as Amity.Serializable,
-    ];
+    const cacheKey = ['message', 'query', params as Amity.Serializable];
     pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
   }
 
+  fireEvent('local.message.fetched', { messages });
+
   const nextPage = toPage(paging.next);
   const prevPage = toPage(paging.previous);
 
@@ -96,9 +80,9 @@ queryMessages.locally = (
 
   if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query;
+  const params = convertQueryParams(query);
 
-  const queryKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = ['message', 'query', params as Amity.Serializable];
   const { data, cachedAt } =
     pullFromCache<{ messages: Pick<Amity.Message, 'messageId'>[] } & Amity.Pagination>(queryKey) ??
     {};

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

@@ -0,0 +1,191 @@
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, generateRawMessage, pause } from '~/utils/tests';
+
+import { convertFromRaw } from '../../utils';
+import { onMessageCreated } from '../../events';
+import { createMessage } from '../createMessage';
+
+const rawMessageToCreate = generateRawMessage();
+const messageToCreate = convertFromRaw(rawMessageToCreate);
+const { messageId, uniqueId, ...messageWithoutId } = messageToCreate;
+
+describe('createMessage', () => {
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    referenceId: 'LOCAL_xxx',
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  const response = {
+    data: { messages: [rawMessageToCreate] },
+  };
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should return created message', async () => {
+    client.http.post = jest.fn().mockResolvedValue(response);
+
+    const { data: created } = await createMessage(bundle);
+
+    expect(created).toMatchObject(messageToCreate);
+    expect(created.uniqueId).toBeDefined();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createMessage(messageWithoutId)).rejects.toThrow('error');
+  });
+
+  test('should put message into cache', async () => {
+    client.http.post = jest.fn().mockResolvedValue(response);
+
+    const { data: created } = await createMessage(bundle);
+
+    const cache = pullFromCache(['message', 'get', created.messageId]);
+    expect(cache).toMatchObject({ data: messageWithoutId });
+  });
+
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(response);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreated(resolve);
+    }).finally(dispose);
+
+    await createMessage(messageWithoutId);
+
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
+  });
+});
+
+describe('createMessage.optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should create cache after created message', () => {
+    const optimisticId = createMessage.optimistically(messageWithoutId)?.data?.messageId;
+    const received = pullFromCache(['message', 'get', optimisticId])?.data;
+
+    expect(received).toMatchObject(messageWithoutId);
+  });
+
+  describe('should increase message count after create message', () => {
+    test('in sub channel', () => {
+      const { channelId, subChannelId } = messageWithoutId;
+      pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
+      pushToCache(['subChannel', 'get', subChannelId], {
+        channelId,
+        subChannelId,
+        messageCount: 2,
+      });
+
+      createMessage.optimistically(messageWithoutId);
+
+      const cacheSubChannel = pullFromCache<Amity.SubChannel>([
+        'subChannel',
+        'get',
+        subChannelId,
+      ])?.data;
+
+      expect(cacheSubChannel?.messageCount).toBe(3);
+    });
+
+    test('in channel if message created in main sub channel', () => {
+      const { subChannelId } = messageWithoutId;
+      pushToCache(['channel', 'get', subChannelId], { channelId: subChannelId, messageCount: 2 });
+      pushToCache(['subChannel', 'get', subChannelId], {
+        channelId: subChannelId,
+        subChannelId,
+        messageCount: 2,
+      });
+
+      createMessage.optimistically(messageWithoutId);
+
+      const cacheChannel = pullFromCache<Amity.Channel>(['channel', 'get', subChannelId])?.data;
+      expect(cacheChannel?.messageCount).toBe(3);
+    });
+  });
+
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreated(resolve);
+    }).finally(dispose);
+
+    createMessage.optimistically(messageWithoutId);
+
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
+  });
+
+  test('should define object as unsynced object', async () => {
+    expect(createMessage.optimistically(messageWithoutId)?.cachedAt).toEqual(
+      UNSYNCED_OBJECT_CACHED_AT_VALUE,
+    );
+  });
+});
+
+describe('uniqueId / referenceId', () => {
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  beforeAll(enableCache);
+
+  afterAll(disableCache);
+
+  it('should optimistically create message with uniqueId', () => {
+    const { data: message } = createMessage.optimistically(bundle)!;
+
+    expect(message.uniqueId).toBeDefined();
+    expect(message.uniqueId).toEqual(message.messageId);
+  });
+
+  it('should update messageId, retain uniqueId if optimistic message is in cache', async () => {
+    const { data: optimisticMessage } = createMessage.optimistically(bundle)!;
+    client.http.post = jest.fn().mockResolvedValue({
+      data: { messages: [{ ...messageToCreate, referenceId: optimisticMessage.uniqueId }] },
+    });
+
+    const { data: message } = await createMessage(bundle);
+
+    expect(client.http.post as jest.Mock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ referenceId: optimisticMessage.uniqueId }),
+    );
+    expect(message.uniqueId).toEqual(optimisticMessage.uniqueId);
+    expect(message.uniqueId).not.toEqual(message.messageId);
+    expect(pullFromCache(['message', 'get', optimisticMessage.uniqueId])).toBeUndefined();
+    expect(pullFromCache(['message', 'get', message.messageId])).toMatchObject({ data: message });
+  });
+
+  it('should set uniqueId to messageId if optimistic message is not in cache', async () => {
+    const rawNewMessage = {
+      ...rawMessageToCreate,
+      messageId: 'new-message-id',
+      referenceId: 'LOCAL_new-message-id',
+    };
+    const callback = jest.fn();
+
+    onMessageCreated(callback);
+    client.emitter.emit('message.created', { messages: [rawNewMessage] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        messageId: rawNewMessage.messageId,
+        uniqueId: rawNewMessage.messageId,
+      }),
+    );
+  });
+});