@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/marker/events/onUserMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onUserMarkerFetched } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserMarkerFetched(userMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category UserMarker Events
+ */
+export const onUserMarkerFetched = (
+  callback: Amity.Listener<Amity.UserMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.userMarker.fetched']) => {
+    callback(payload.userMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'userMarker/onUserMarkerFetched',
+    'local.userMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onUserMarkerSync.ts

@@ -0,0 +1,31 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onUserMarkerSync } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserMarkerSync(UserMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMarker} has been sync
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category UserMarker Events
+ */
+export const onUserMarkerSync = (
+  callback: Amity.Listener<Amity.UserMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['marker.user-sync']) => {
+    ingestInCache(payload);
+    callback(payload.userMarkers[0]);
+  };
+
+  return createEventSubscriber(client, 'UserMarker/onUserMarkerSync', 'marker.user-sync', filter);
+};

package/src/messageRepository/api/createMessage.ts

@@ -0,0 +1,167 @@
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
+
+import { convertParams, prepareMessagePayload } from '../utils';
+
+const getLocalId = () => `LOCAL_${uuid()}`;
+
+// FIXME: temp solution
+let uniqueId: string | undefined;
+
+/* begin_public_function
+  id: message.create.text_message, message.create.image_message, message.create.file_message, message.create.video_message, message.create.audio_message, message.create.custom_message
+*/
+/**
+ * ```js
+ * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk-react-native'
+ *
+ * const query = createQuery(createMessage, {
+ *   subChannelId: 'foobar',
+ *   data: { text: 'hello world' },
+ * });
+ *
+ * runQuery(query, ({ data: message, loading }) => {
+ *   console.log(message);
+ * });
+ * ```
+ *
+ * Creates an {@link Amity.Message}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ * @async
+ */
+export const createMessage = async <T extends Amity.MessageContentType>(
+  bundle: Pick<
+    Amity.Message<T>,
+    'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
+  > & {
+    data?: Amity.Message<T>['data'];
+    fileId?: Amity.File['fileId'];
+    // Custom referenceId is a workaround for the case:
+    // User wants to create an image message. He should
+    // - create and show dummy message in ui
+    // - upload image to get fileId, while uploading show a spinner in dummy message in ui
+    // - call createMessage and pass fileId
+    // - replace dummy message with the actual message received from backend
+    // Custom referenceId is needed to make relation between dummy message and actual message.
+    // TODO: passing file src into createMessage so that sdk uploads files itself,
+    // returns the dummy message bound with the file to eliminate the need to create
+    // the dummy message on the user side,
+    referenceId?: string;
+  },
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/createMessage', bundle);
+
+  const referenceId = bundle.referenceId || uniqueId || getLocalId();
+  uniqueId = undefined;
+
+  const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
+    ...convertParams(bundle),
+    referenceId,
+  });
+
+  const data = await prepareMessagePayload(payload);
+  const { messages } = data;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    dropFromCache(['message', 'get', referenceId]);
+    ingestInCache(data, { cachedAt });
+  }
+
+  fireEvent('local.message.created', { messages });
+
+  return {
+    data: messages[0],
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { createMessage } from '@amityco/ts-sdk-react-native'
+ *
+ * const created = createMessage.optimistically({
+ *   channelId: 'foobar',
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Creates an {@link Amity.Message} in cache
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Message}
+ * @returns The newly created {@link Amity.Message}
+ *
+ * @category Message API
+ */
+createMessage.optimistically = ({
+  referenceId,
+  ...bundle
+}: Parameters<typeof createMessage>[0]): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+
+  if (!client.cache) return;
+
+  /*
+   * 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!
+   */
+  uniqueId = referenceId || getLocalId();
+  const bundleWithMessageId = { messageId: uniqueId, uniqueId, ...bundle };
+
+  client.log('message/createMessage.optimistically', bundleWithMessageId);
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', bundle.subChannelId]);
+
+  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 = {
+    creatorId: client.userId!,
+    channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
+    childrenNumber: 0,
+    createdAt: createdTime,
+    updatedAt: createdTime,
+    ...bundleWithMessageId,
+  } as Amity.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,
+  };
+};
+/* end_public_function */

package/src/messageRepository/api/deleteMessage.ts

@@ -0,0 +1,68 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+import { getMessage } from './getMessage';
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk-react-native'
+ * const success = await deleteMessage('foobar')
+ * ```
+ *
+ * Delete a {@link Amity.Message}
+ *
+ * @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
+ * @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/v5/messages/${encodeURIComponent(messageId)}`,
+  );
+  const deleted = await getMessage(messageId);
+  fireEvent('local.message.deleted', { messages: [deleted.data] });
+  return deleted.data;
+};
+
+/**
+ * ```js
+ * import { deleteMessage } from '@amityco/ts-sdk-react-native'
+ * const success = deleteMessage.optimistically('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.optimistically', 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('local.message.deleted', { messages: [deleted] });
+  return {
+    data: deleted,
+    cachedAt,
+  };
+};

package/src/messageRepository/api/editMessage.ts

@@ -0,0 +1,100 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+import { convertParams, prepareMessagePayload } from '../utils';
+
+/* begin_public_function
+  id: message.edit.text_message, message.edit.custom_message
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk-react-native'
+ * const updated = await MessageRepository.editMessage(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 editMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/editMessage', patch);
+
+  const { data: payload } = await client.http.put<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    convertParams(patch),
+  );
+
+  const data = await prepareMessagePayload(payload);
+
+  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,
+  };
+};
+
+/**
+ * ```js
+ * import { editMessage } from '@amityco/ts-sdk-react-native'
+ * const updated = editMessage.optimistically('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
+ */
+editMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/editMessage.optimistically', patch);
+
+  if (!client.cache) return;
+
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const edited: Amity.Message = {
+    ...message.data,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], edited, { cachedAt });
+  fireEvent('local.message.updated', { messages: [edited] });
+
+  return {
+    data: edited,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/messageRepository/api/flagMessage.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/* begin_public_function
+  id: message.flag
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk-react-native'
+ * const flagged = await MessageRepository.flagMessage(messageId)
+ * ```
+ *
+ * @param messageId of the message to flag
+ * @returns the created report result
+ *
+ * @category Message API
+ * @async
+ * */
+export const flagMessage = async (messageId: Amity.Message['messageId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/flag', messageId);
+
+  const { data: payload } = await client.http.post<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent('message.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/messageRepository/api/getDeliveredUsers.ts

@@ -0,0 +1,114 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { toPage, toToken } from '~/core/query';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getUserByIds } from '~/userRepository';
+
+/**
+ * ```js
+ * import { getDeliveredUsers } from '@amityco/ts-sdk-react-native'
+ * const { data: users, prevPage, nextPage } = await getDeliveredUsers({
+ *   messageId: 'foo',
+ * })
+ * ```
+ *
+ * Queries a paginable list of delivered {@link Amity.User} by messageId
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category Message API
+ * @async
+ */
+export const getDeliveredUsers = async (
+  query: Amity.QueryDeliveredUsers,
+): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
+  const client = getActiveClient();
+  client.log('user/getDeliveredUsers', query);
+
+  const { page, messageId, ...params } = query;
+
+  const { data } = await client.http.get<Amity.DeliveredUserPayload & Amity.Pagination>(
+    `/api/v1/markers/messages/${messageId}/delivered-users`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'afterbeforeraw'),
+        },
+      },
+    },
+  );
+
+  const { paging, publicUserIds: deliveredUsers, ...payload } = data;
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Omit<Amity.DeliveredUserPayload, 'publicUserIds'>, { cachedAt });
+
+    const cacheKey = [
+      'delivered-user',
+      'query',
+      { messageId, ...params, options: { ...page } } as Amity.Serializable,
+    ];
+
+    pushToCache(cacheKey, { users: deliveredUsers, paging });
+  }
+
+  let users: Amity.User[] = [];
+
+  if (deliveredUsers.length > 0) {
+    ({ data: users } = await getUserByIds(deliveredUsers));
+  }
+
+  const prevPage = toPage(paging.previous);
+  const nextPage = toPage(paging.next);
+
+  return { data: users, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { getDeliveredUsers } from '@amityco/ts-sdk-react-native'
+ * const { data: users } = getDeliveredUsers.locally({
+ *   messageId: 'foo',
+ * })
+ * ```
+ *
+ * Queries a paginable list of delivered {@link Amity.User} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.User} objects
+ *
+ * @category Message API
+ */
+getDeliveredUsers.locally = (
+  query: Amity.QueryDeliveredUsers,
+): Amity.Cached<Amity.Paged<Amity.User>> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getDeliveredUsers.locally', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query;
+
+  const cacheKey = [
+    'delivered-user',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<{ users: Pick<Amity.SubChannelMarker, 'userId'>[] } & Amity.Pagination>(
+      cacheKey,
+    ) ?? {};
+
+  const users = data?.users.map(userId => pullFromCache<Amity.User>(['user', 'get', userId])?.data);
+
+  if (!users || users.some(user => !user)) return;
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return { data: users as Amity.User[], cachedAt, prevPage, nextPage };
+};

package/src/messageRepository/api/getMessage.ts

@@ -0,0 +1,101 @@
+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 { prepareMessagePayload } from '../utils';
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk-react-native'
+ * 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.ProcessedMessagePayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const { data: payload } = await client.http.get<Amity.MessagePayload>(
+      `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    );
+
+    data = await prepareMessagePayload(payload);
+  } 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,
+  };
+};
+
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk-react-native'
+ * 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,
+  };
+};