@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/messagePreview/utils/updateMessagePreviewFromMessage.ts

@@ -1,278 +0,0 @@
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { updateSubChannelCache } from '../../subChannelRepository/utils/updateSubChannelCache';
-import { getSubChannel } from '~/subChannelRepository/api/getSubChannel';
-import { getActiveClient } from '~/client/api/activeClient';
-import { convertDateStringToTimestamp } from '~/utils/dateTime';
-
-const getMessagePreviewSetting = async () => {
-  const client = getActiveClient();
-  return client.getMessagePreviewSetting(false);
-};
-
-const getSubChannelCache = async (subChannelId: string): Promise<Amity.SubChannel> => {
-  let subChannelCache = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId])?.data;
-
-  if (!subChannelCache) {
-    subChannelCache = (await getSubChannel(subChannelId)).data;
-  }
-
-  return subChannelCache;
-};
-
-const isLastestMessageOnSubchannel = (message: Amity.InternalMessage) => {
-  const cache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewSubChannel',
-    'get',
-    message.subChannelId,
-  ])?.data;
-  // The message payload from optimistic created event has no segment, so we check createdAt instead.
-  return (
-    !cache ||
-    cache.segment <= message.channelSegment ||
-    convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt)
-  );
-};
-
-const isLastestMessageOnChannel = (message: Amity.InternalMessage) => {
-  const cache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewChannel',
-    'get',
-    message.channelId,
-  ])?.data;
-  return (
-    !cache ||
-    convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt)
-  );
-};
-
-export const handleMessageCreatedOnSubChannel = async (message: Amity.InternalMessage) => {
-  const messagePreviewSetting = await getMessagePreviewSetting();
-
-  const {
-    channelId,
-    messageId: messagePreviewId,
-    creatorId,
-    createdAt,
-    updatedAt,
-    data,
-    dataType,
-    subChannelId,
-    channelSegment: segment,
-    isDeleted,
-  } = message;
-
-  // 1. get subChannel from cache, if not exist fetch from server
-  const subChannelCache = await getSubChannelCache(subChannelId);
-
-  // 2. if messagePreviewSetting is NO_MESSAGE_PREVEIW, update only lastActiviy in subChannel cache
-  if (messagePreviewSetting === Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW) {
-    // 2.1 if the message is the latest message, update lastActivity to be createdAt in subChannel cache
-    if (
-      convertDateStringToTimestamp(subChannelCache.lastActivity) <
-      convertDateStringToTimestamp(createdAt)
-    )
-      updateSubChannelCache(message.subChannelId, subChannelCache as Amity.SubChannel, {
-        lastActivity: createdAt,
-      });
-
-    return;
-  }
-
-  // 3. if messagePreviewSetting is `NOT` NO_MESSAGE_PREVEIW, update messagePreviewSubChannel and subChannel cache
-  // 3.1 check if the message is the latest message, if not ignore the message.
-  if (!isLastestMessageOnSubchannel(message)) return;
-
-  // 3.2 if the message is the latest message, update messagePreviewSubChannel and subChannel cache
-  pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
-    channelId,
-    creatorId,
-    messagePreviewId,
-    createdAt,
-    updatedAt,
-    subChannelId,
-    data,
-    dataType,
-    segment,
-    isDeleted,
-    subChannelUpdatedAt: subChannelCache?.updatedAt!,
-    subChannelName: subChannelCache?.displayName,
-  } as Amity.InternalMessagePreview);
-
-  updateSubChannelCache(message.subChannelId, subChannelCache as Amity.SubChannel, {
-    lastActivity: createdAt,
-    messagePreviewId,
-  });
-};
-
-export const handleMessageUpdatedOnSubChannel = async (message: Amity.InternalMessage) => {
-  const {
-    channelId,
-    messageId: messagePreviewId,
-    creatorId,
-    createdAt,
-    updatedAt,
-    data,
-    dataType,
-    subChannelId,
-    channelSegment: segment,
-    isDeleted,
-  } = message;
-
-  const messagePreviewSubChannelCache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewSubChannel',
-    'get',
-    message.subChannelId,
-  ])?.data;
-
-  // if messagePreviewSubChannel is not exist, ignore the message.
-  if (
-    messagePreviewSubChannelCache &&
-    messagePreviewSubChannelCache.messagePreviewId === message.messageId
-  ) {
-    const subChannelCache = await getSubChannelCache(subChannelId);
-    pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
-      channelId,
-      creatorId,
-      messagePreviewId,
-      createdAt,
-      updatedAt,
-      subChannelId,
-      data,
-      dataType,
-      segment,
-      isDeleted,
-      subChannelUpdatedAt: subChannelCache.updatedAt,
-      subChannelName: messagePreviewSubChannelCache.subChannelName,
-    } as Amity.InternalMessagePreview);
-  }
-};
-
-export const handleMessageCreated = async (message: Amity.InternalMessage) => {
-  const {
-    channelId,
-    messageId: messagePreviewId,
-    creatorId,
-    createdAt,
-    updatedAt,
-    data,
-    dataType,
-    subChannelId,
-    channelSegment: segment,
-    isDeleted,
-  } = message;
-
-  if (isLastestMessageOnChannel(message)) {
-    const subChannelCache = await getSubChannelCache(subChannelId);
-
-    pushToCache(['messagePreviewChannel', 'get', message.channelId], {
-      channelId,
-      creatorId,
-      messagePreviewId,
-      createdAt,
-      updatedAt,
-      subChannelId,
-      data,
-      dataType,
-      segment,
-      isDeleted,
-      subChannelUpdatedAt: subChannelCache?.updatedAt!,
-      subChannelName: subChannelCache?.displayName,
-    } as Amity.InternalMessagePreview);
-  }
-};
-
-export const handleMessageUpdated = async (message: Amity.InternalMessage) => {
-  /**
-   * Channel Case
-   */
-
-  const {
-    channelId,
-    messageId: messagePreviewId,
-    creatorId,
-    createdAt,
-    updatedAt,
-    data,
-    dataType,
-    subChannelId,
-    channelSegment: segment,
-    isDeleted,
-  } = message;
-
-  const messagePreviewChannelCache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewChannel',
-    'get',
-    message.channelId,
-  ])?.data;
-
-  if (
-    messagePreviewChannelCache &&
-    messagePreviewChannelCache.messagePreviewId === message.messageId
-  ) {
-    const subChannelCache = await getSubChannelCache(subChannelId);
-    pushToCache(['messagePreviewChannel', 'get', message.channelId], {
-      channelId,
-      creatorId,
-      messagePreviewId,
-      createdAt,
-      updatedAt,
-      subChannelId,
-      data,
-      dataType,
-      segment,
-      isDeleted,
-      subChannelUpdatedAt: subChannelCache.updatedAt,
-      subChannelName: messagePreviewChannelCache.subChannelName,
-    } as Amity.InternalMessagePreview);
-  }
-};
-
-export const handleSubChannelUpdated = async (subChannel: Amity.SubChannel) => {
-  const { channelId, subChannelId } = subChannel;
-
-  /** Channel Case */
-  const messagePreviewChannelCache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewChannel',
-    'get',
-    channelId,
-  ])?.data;
-
-  if (messagePreviewChannelCache?.subChannelId === subChannelId) {
-    const subChannelCache = pullFromCache<Amity.SubChannel>([
-      'subChannel',
-      'get',
-      subChannelId,
-    ])?.data;
-
-    pushToCache(['messagePreviewChannel', 'get', channelId], {
-      ...messagePreviewChannelCache,
-      subChannelName: subChannelCache?.displayName,
-      subChannelUpdatedAt: subChannelCache?.updatedAt!,
-    } as Amity.InternalMessagePreview);
-  }
-
-  /** SubChannel Case */
-  const messagePreviewSubChannelCache = pullFromCache<Amity.InternalMessagePreview>([
-    'messagePreviewSubChannel',
-    'get',
-    subChannelId,
-  ])?.data;
-
-  if (
-    messagePreviewSubChannelCache &&
-    new Date(messagePreviewSubChannelCache.updatedAt!).valueOf() >
-      new Date(subChannel.updatedAt!).valueOf()
-  ) {
-    const subChannelCache = pullFromCache<Amity.SubChannel>([
-      'subChannel',
-      'get',
-      subChannelId,
-    ])?.data;
-
-    pushToCache(['messagePreviewSubChannel', 'get', subChannelId], {
-      ...messagePreviewSubChannelCache,
-      subChannelName: subChannelCache?.displayName,
-      subChannelUpdatedAt: subChannelCache?.updatedAt!,
-    } as Amity.InternalMessagePreview);
-  }
-};

package/src/messagePreview/utils/updateSubChannelMessagePreviewCache.ts

@@ -1,43 +0,0 @@
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-export const updateSubChannelMessagePreviewCache = (rawPayload: Amity.SubChannelPayload) => {
-  const withMessageFeedInfo = (messagePreview: Amity.SubChannelMessagePreviewPayload) => {
-    const messageFeedInfo = rawPayload.messageFeeds?.find(messageFeed => {
-      return messageFeed.messageFeedId === messagePreview.messageFeedId;
-    });
-
-    const {
-      channelPublicId: channelId,
-      messageFeedId: subChannelId,
-      messageId: messagePreviewId,
-      creatorPublicId: creatorId,
-      data,
-      dataType,
-      isDeleted,
-      segment,
-      createdAt,
-      updatedAt,
-    } = messagePreview;
-
-    return {
-      messagePreviewId,
-      channelId,
-      subChannelId,
-      data,
-      dataType,
-      isDeleted,
-      segment,
-      creatorId,
-      createdAt,
-      updatedAt,
-      subChannelName: messageFeedInfo?.name!,
-      subChannelUpdatedAt: messageFeedInfo?.updatedAt!,
-    };
-  };
-  const newData = {
-    messagePreviewSubChannel:
-      rawPayload.messages?.map(messagePreview => withMessageFeedInfo(messagePreview)) ?? [],
-  };
-
-  ingestInCache(newData);
-};

package/src/messageRepository/api/createMessage.ts

@@ -1,160 +0,0 @@
-import { uuid } from '~/core/uuid';
-import { fireEvent } from '~/core/events';
-import { getActiveClient, getActiveUser } from '~/client/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
-import { dropFromCache, pullFromCache, pushToCache, upsertInCache } from '~/cache/api';
-
-import { LinkedObject } from '~/utils/linkedObject';
-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
-*/
-
-type createMessageParam<T extends Amity.MessageContentType> = Pick<
-  Amity.Message<T>,
-  'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
-> & {
-  data?: Amity.Message<T>['data'];
-  fileId?: Amity.File['fileId'];
-  referenceId?: string;
-};
-
-const createMessageOptimistic = <T extends Amity.MessageContentType>(
-  bundle: createMessageParam<T>,
-): Amity.InternalMessage | 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 to allow backward compatibility of API
-   *
-   * Updated to handle client requirement to add messageId while uploading
-   * a message with image.
-   * Temporary!
-   */
-  uniqueId = bundle.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.StaticInternalChannel>([
-        '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!,
-    creatorPrivateId: getActiveUser()._id,
-    channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
-    childrenNumber: 0,
-    createdAt: createdTime,
-    updatedAt: createdTime,
-    syncState: Amity.SyncState.Syncing,
-    isDeleted: false,
-    ...bundleWithMessageId,
-  } as Amity.InternalMessage;
-
-  const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
-
-  pushToCache(['message', 'get', message.messageId], message, { cachedAt });
-
-  fireEvent('local.message.created', { messages: [message] });
-
-  return message;
-};
-/**
- * ```js
- * 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}
- *
- * @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: createMessageParam<T>,
-): Promise<Amity.Cached<Amity.Message>> => {
-  const client = getActiveClient();
-
-  client.log('message/createMessage', bundle);
-
-  const optimisticData = createMessageOptimistic<T>(bundle);
-
-  const referenceId = bundle.referenceId || uniqueId || getLocalId();
-  uniqueId = undefined;
-
-  try {
-    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) {
-      ingestInCache(data, { cachedAt });
-    }
-
-    fireEvent('local.message.created', {
-      messages: [{ ...messages[0], syncState: Amity.SyncState.Synced }],
-    });
-
-    return {
-      data: LinkedObject.message(messages[0]),
-      cachedAt,
-    };
-  } catch (e) {
-    fireEvent('local.message.created', {
-      messages: [{ ...optimisticData, syncState: Amity.SyncState.Error } as Amity.InternalMessage],
-    });
-
-    throw e;
-  }
-};
-/* end_public_function */

package/src/messageRepository/api/deleteMessage.ts

@@ -1,89 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { pullFromCache, upsertInCache } from '~/cache/api';
-import { fireEvent } from '~/core/events';
-import { LinkedObject } from '~/utils/linkedObject';
-import { prepareMessagePayload } from '../utils';
-/**
- * ```js
- * import { deleteMessage } from '@amityco/ts-sdk'
- * 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);
-
-  if (messageId.includes('LOCAL_')) {
-    const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])?.data;
-    if (!message) throw Error('messageId not found');
-
-    const deletedMessage = {
-      ...message,
-      isDeleted: true,
-    };
-
-    fireEvent('local.message.deleted', {
-      messages: [deletedMessage],
-    });
-
-    return LinkedObject.message(deletedMessage);
-  }
-
-  // API-FIX: This endpoint has not been implemented yet.
-  const { data: deleted } = await client.http.delete<Amity.MessagePayload>(
-    `/api/v5/messages/${encodeURIComponent(messageId)}`,
-  );
-
-  const payload = await prepareMessagePayload(deleted);
-
-  fireEvent('local.message.deleted', {
-    messages: [payload.messages[0]],
-  });
-  return LinkedObject.message(payload.messages[0]);
-};
-
-/**
- * ```js
- * import { deleteMessage } from '@amityco/ts-sdk'
- * 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.InternalMessage>(['message', 'get', messageId]);
-
-  if (!message) return;
-  const cachedAt = -1;
-  const deleted: Amity.InternalMessage = {
-    ...message.data,
-    isDeleted: true,
-    updatedAt: new Date().toISOString(),
-  };
-  upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
-  fireEvent('local.message.deleted', { messages: [deleted] });
-  return {
-    data: LinkedObject.message(deleted),
-    cachedAt,
-  };
-};

package/src/messageRepository/api/editMessage.ts

@@ -1,101 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: message.edit.text_message, message.edit.custom_message
-*/
-/**
- * ```js
- * import { MessageRepository } from '@amityco/ts-sdk'
- * 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: LinkedObject.message(messages.find(message => message.messageId === messageId)!),
-    cachedAt,
-  };
-};
-
-/**
- * ```js
- * import { editMessage } from '@amityco/ts-sdk'
- * 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.InternalMessage>(['message', 'get', messageId]);
-
-  if (!message) return;
-
-  const cachedAt = -1;
-  const edited: Amity.InternalMessage = {
-    ...message.data,
-    ...patch,
-    updatedAt: new Date().toISOString(),
-  };
-
-  upsertInCache(['message', 'get', messageId], edited, { cachedAt });
-  fireEvent('local.message.updated', { messages: [edited] });
-
-  return {
-    data: LinkedObject.message(edited),
-    cachedAt,
-  };
-};
-/* end_public_function */