@amityco/ts-sdk 0.0.1-003998f.0

package/src/message/api/deleteMessage.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api';
+
+import { getMessage } from './getMessage';
+
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = await deleteMessage('foobar')
+ * ```
+ *
+ * Delete a {@link Amity.Message}
+ *
+ * @param The ID of the {@link Amity.Message} to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ * @async
+ */
+export const deleteMessage = async (
+  messageId: Amity.Message['messageId'],
+): Promise<Amity.Message> => {
+  const client = getActiveClient();
+  client.log('message/deleteMessage', messageId);
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+  );
+
+  const deleted = await getMessage(messageId);
+
+  fireEvent('v3.message.didDelete', { messages: [deleted.data] });
+
+  return deleted.data;
+};
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk'
+ * const success = deleteMessage.locally('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Message}
+ *
+ * @param messageId The {@link Amity.Message} ID to delete
+ * @return A success boolean if the {@link Amity.Message} was deleted
+ *
+ * @category Message API
+ */
+deleteMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/deleteMessage', messageId);
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const deleted: Amity.Message = {
+    ...message.data,
+    isDeleted: true,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
+  fireEvent('v3.message.didDelete', { messages: [deleted] });
+
+  return {
+    data: deleted,
+    cachedAt,
+  };
+};

package/src/message/api/getMessage.ts

@@ -0,0 +1,99 @@
+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';
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = await getMessage('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessage = async (
+  messageId: Amity.Message['messageId'],
+  isLive = false,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/getMessage', 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.MessagePayload>(
+      `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    );
+
+    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('v3.message.didFetch', { messages });
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk'
+ * const message = getMessage.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Message} object
+ *
+ * @param messageId the ID of the {@link Amity.Message} to fetch
+ * @returns the associated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+getMessage.locally = (
+  messageId: Amity.Message['messageId'],
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessage.locally', messageId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/message/api/getMessages.ts

@@ -0,0 +1,79 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = await getMessages(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+export const getMessages = async (
+  messageIds: Amity.Message['messageId'][],
+): Promise<Amity.Cached<Amity.Message[]>> => {
+  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 cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('v3.message.didFetch', { messages });
+
+  return {
+    data: messages,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk'
+ * const messages = getMessages.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Message} objects from cache
+ *
+ * @param messageIds the IDs of the {@link Amity.Message} to fetch
+ * @returns the associated collection of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+getMessages.locally = (
+  messageIds: Amity.Message['messageId'][],
+): Amity.Cached<Amity.Message[]> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessages.locally', messageIds);
+
+  if (!client.cache) return;
+
+  const cached = messageIds
+    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+    .filter(Boolean);
+
+  const messages = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < messageIds.length) return;
+
+  return {
+    data: messages,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/message/api/index.ts

@@ -0,0 +1,6 @@
+export * from './getMessage';
+export * from './getMessages';
+export * from './queryMessages';
+export * from './createMessage';
+export * from './updateMessage';
+export * from './deleteMessage';

package/src/message/api/queryMessages.ts

@@ -0,0 +1,115 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { toPage, toToken } from '~/core/query';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+/**
+ * ```js
+ * import { queryMessages } from '@amityco/ts-sdk'
+ * const messages = await queryMessages({ channelId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Message} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Message} objects
+ *
+ * @category Message API
+ * @async
+ */
+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;
+
+  // 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'),
+        },
+      },
+    },
+  );
+
+  // API-FIX: backend should answer Amity.Response (2)
+  // const { paging, messages } = unwrapPayload(data)
+
+  const { paging, ...payload } = data;
+  const { messages } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.MessagePayload, { cachedAt });
+
+    const cacheKey = [
+      'message',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
+  }
+
+  fireEvent('v3.message.didFetch', { messages });
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: messages, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryMessages } from '@amityco/ts-sdk'
+ * const messages = queryMessages.locally!({ channelId })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Message} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Message} objects
+ *
+ * @category Message API
+ */
+queryMessages.locally = (
+  query: Parameters<typeof queryMessages>[0],
+): Amity.Cached<Amity.Paged<Amity.Message>> | undefined => {
+  const client = getActiveClient();
+  client.log('message/queryMessages.locally', query);
+
+  if (!client.cache) return;
+
+  const { page = { limit: 10 }, ...params } = query;
+
+  const queryKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ messages: Pick<Amity.Message, 'messageId'>[] } & Amity.Pagination>(queryKey) ??
+    {};
+
+  if (!data?.messages.length) return;
+
+  const messages: Amity.Message[] = data.messages
+    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return messages.length === data?.messages?.length
+    ? { data: messages, cachedAt, prevPage, nextPage }
+    : undefined;
+};

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

@@ -0,0 +1,76 @@
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+
+import { client, message11 } from '~/utils/tests';
+
+import { onMessageCreated } from '../../events';
+import { createMessage } from '../createMessage';
+
+describe('message/api', () => {
+  const message = message11;
+  const { messageId, ...messageBundle } = message11;
+
+  const getResolvedMessageValue = () => ({
+    data: {
+      messages: [message],
+      users: [],
+      files: [],
+    },
+  });
+
+  describe('createMessage', () => {
+    test('should return message', async () => {
+      client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
+      const { data } = await createMessage(messageBundle);
+      expect(data).toStrictEqual(message);
+    });
+
+    test('should throw an error if request fails', async () => {
+      client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+      await expect(createMessage(messageBundle)).rejects.toThrow('error');
+    });
+  });
+
+  describe('createMessage.optimistically', () => {
+    beforeEach(() => enableCache());
+    afterEach(() => disableCache());
+
+    test('should create cache after created message', () => {
+      const optimisticId = createMessage.optimistically(messageBundle)?.data?.messageId;
+      expect(pullFromCache(['message', 'get', optimisticId])?.data).toBeDefined();
+    });
+
+    test('should increase message count after created message', () => {
+      const { channelId } = messageBundle;
+
+      const currentCount =
+        pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data?.messageCount ?? 0;
+
+      createMessage.optimistically(messageBundle);
+
+      expect(
+        pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data?.messageCount,
+      ).toEqual(currentCount + 1);
+    });
+
+    test('should fire event `onMessageCreated`', () => {
+      expect.assertions(1);
+      let dispose;
+
+      const callback = new Promise(resolve => {
+        dispose = onMessageCreated(resolve);
+      }).finally(dispose);
+
+      createMessage.optimistically(messageBundle);
+      return expect(callback).resolves.not.toThrow();
+    });
+
+    test('should define object as unsynced object', async () => {
+      const data = { channelId: 'test', data: { text: 'text' } };
+
+      const message = createMessage.optimistically(data);
+
+      expect(message?.cachedAt).toEqual(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    });
+  });
+});

package/src/message/api/updateMessage.ts

@@ -0,0 +1,92 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = await updateMessage(messageId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message}
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const updateMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('user/updateMessage', patch);
+
+  const { data } = await client.http.put<Amity.MessagePayload>(
+    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    patch,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('v3.message.didUpdate', { messages });
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = updateMessage.locally('foobar', {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message} in cache
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+updateMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('user/updateMessage', patch);
+
+  if (!client.cache) return;
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const updated: Amity.Message = {
+    ...message.data,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], updated, { cachedAt });
+  fireEvent('v3.message.didUpdate', { messages: [updated] });
+
+  return {
+    data: updated,
+    cachedAt,
+  };
+};

package/src/message/events/index.ts

@@ -0,0 +1,4 @@
+export * from './onMessageCreated';
+export * from './onMessageUpdated';
+export * from './onMessageDeleted';
+export * from './onMessageFetched';

package/src/message/events/onMessageCreated.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onMessageCreated } from '@amityco/ts-sdk'
+ * const dispose = onMessageCreated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been created
+ *
+ * @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 onMessageCreated = (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/onMessageCreated', 'v3.message.didCreate', filter);
+};

package/src/message/events/onMessageDeleted.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} was deleted
+ *
+ * @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 onMessageDeleted = (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/onMessageDeleted', 'v3.message.didDelete', filter);
+};

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/events/onMessageUpdated.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayloadForCache } from '~/reaction/utils';
+
+/**
+ * ```js
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.Message} has been updated
+ *
+ * @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 onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.MessagePayload) => {
+    ingestInCache(payload);
+    const message = payload.messages[0];
+
+    // if payload does not have myReactions
+    if (!message?.myReactions) {
+      prepareMessagePayloadForCache(message);
+    }
+
+    callback(message);
+  };
+
+  return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);
+};

package/src/message/observers/index.ts

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