@amityco/ts-sdk 6.35.3-f8f74ab5.0 → 6.35.3

package/src/messageRepository/internalApi/getMessages.ts

@@ -0,0 +1,82 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareMessagePayload } from '../utils';
+
+/**
+ * ```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.InternalMessage[]>> => {
+  const client = getActiveClient();
+  client.log('message/getMessages', messageIds);
+
+  const { data: payload } = await client.http.get<Amity.MessagePayload>(`/api/v5/messages/list`, {
+    params: { messageIds: messageIds.map(encodeURIComponent) },
+  });
+
+  const data = await prepareMessagePayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { 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.InternalMessage[]> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessages.locally', messageIds);
+
+  if (!client.cache) return;
+
+  const cached = messageIds
+    .map(messageId => pullFromCache<Amity.InternalMessage>(['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/messageRepository/observers/getMessage.ts

@@ -0,0 +1,63 @@
+import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
+import { convertEventPayload } from '~/utils/event';
+import { liveObject } from '~/utils/liveObject';
+import { getMessage as _getMessage } from '../internalApi/getMessage';
+import {
+  onMessageUpdated,
+  onMessageDeleted,
+  onMessageFlagged,
+  onMessageUnflagged,
+  onMessageFlagCleared,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+} from '../events';
+import { onMessageFetched } from '../events/onMessageFetched';
+import { LinkedObject } from '~/utils/linkedObject';
+import { date } from '~/utils/tests';
+
+/* begin_public_function
+  id: message.get
+*/
+/**
+ * ```js
+ * import { getMessage } from '@amityco/ts-sdk';
+ *
+ * let message;
+ *
+ * const unsubscribe = getMessage(messageId, response => {
+ *   message = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Message}
+ *
+ * @param messageId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ *
+ * @category Message Live Object
+ */
+export const getMessage = (
+  messageId: Amity.Message['messageId'],
+  callback: Amity.LiveObjectCallback<Amity.Message>,
+): Amity.Unsubscriber => {
+  const responder: Amity.LiveObjectCallback<Amity.InternalMessage> = (
+    snapshot: Amity.LiveObject<Amity.InternalMessage>,
+  ) => {
+    const { data } = snapshot;
+    callback({ ...snapshot, data: data ? LinkedObject.message(snapshot.data) : data });
+  };
+  return liveObject(messageId, responder, 'messageId', _getMessage, [
+    onMessageFetched,
+    onMessageUpdated,
+    onMessageDeleted,
+    onMessageFlagged,
+    onMessageUnflagged,
+    onMessageFlagCleared,
+    onMessageReactionAdded,
+    onMessageReactionRemoved,
+    convertEventPayload(onMessageMarkerFetched, 'contentId', 'message'),
+    convertEventPayload(onMessageMarked, 'contentId', 'message'),
+  ]);
+};
+/* end_public_function */

package/src/messageRepository/observers/getMessages/MessageLiveCollectionController.ts

@@ -0,0 +1,166 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import {
+  onMessageCreatedLocal,
+  onMessageCreatedMqtt,
+  onMessageDeleted,
+  onMessageFlagCleared,
+  onMessageFlagged,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+  onMessageUnflagged,
+  onMessageUpdated,
+} from '~/messageRepository/events';
+import { convertEventPayload } from '~/utils/event';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
+import { filterByPropEquality } from '~/core/query';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+import { MessageQueryStreamController } from './MessageQueryStreamController';
+import { MessagePaginationController } from './MessagePaginationController';
+import { getMessageFromMainDB } from '~/messageRepository/utils/getMessageFromMainDB';
+
+export class MessageLiveCollectionController extends LiveCollectionController<
+  'message',
+  Amity.MessagesLiveCollection,
+  Amity.Message,
+  MessagePaginationController
+> {
+  private queryStreamController: MessageQueryStreamController;
+
+  private query: Amity.MessagesLiveCollection;
+
+  constructor(
+    query: Amity.MessagesLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Message>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['message', 'collection', queryStreamId];
+    const paginationController = new MessagePaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new MessageQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareMessagePayload,
+      this.paginationController,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onMessageCreatedMqtt, action: 'onCreate' },
+      { fn: onMessageCreatedLocal, action: 'onCreate' },
+      { fn: onMessageDeleted, action: 'onDelete' },
+      { fn: onMessageUpdated, action: 'onUpdate' },
+      { fn: onMessageFlagged, action: 'onFlagged' },
+      { fn: onMessageUnflagged, action: 'onUnflagged' },
+      { fn: onMessageFlagCleared, action: 'onFlagCleared' },
+      { fn: onMessageReactionAdded, action: 'onReactionAdded' },
+      { fn: onMessageReactionRemoved, action: 'onReactionRemoved' },
+      {
+        fn: convertEventPayload(onMessageMarkerFetched, 'contentId', 'message'),
+        action: 'onUpdate',
+      },
+      { fn: convertEventPayload(onMessageMarked, 'contentId', 'message'), action: 'onUpdate' },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(messageId => getMessageFromMainDB(messageId)!)
+        .filter(Boolean)
+        .map(message => LinkedObject.message(message)) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      onPrevPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.PREV }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      hasPrevPage: !!this.paginationController.getPrevToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Message[]) {
+    let messages = data;
+
+    messages = messages.filter(m => {
+      if (this.query.tags) {
+        return this.query.tags.find(value => {
+          if (!m.tags) return false;
+          return m.tags.includes(value);
+        });
+      }
+      return true;
+    });
+
+    messages = messages.filter(m => {
+      if (this.query.excludeTags) {
+        return (this.query.excludeTags || []).find(value => {
+          if (!m.tags) return true;
+          return !m.tags.includes(value);
+        });
+      }
+      return true;
+    });
+
+    /*
+     * for cases when message is deleted via RTE, this flag is used to get
+     * items from cache that are !deleted
+     */
+    if (!this.query.includeDeleted) {
+      messages = filterByPropEquality(messages, 'isDeleted', false);
+    }
+
+    messages = messages.sort((message1, message2) => {
+      if (this.query.sortBy === 'segmentAsc') {
+        return message1.channelSegment - message2.channelSegment;
+      }
+      if (this.query.sortBy === 'segmentDesc') {
+        return message2.channelSegment - message1.channelSegment;
+      }
+      return 0;
+    });
+
+    return messages;
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        query: this.query,
+      });
+    }
+  }
+
+  protected async persistModel(response: Amity.MessagePayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'message'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+}

package/src/messageRepository/observers/getMessages/MessagePaginationController.ts

@@ -0,0 +1,33 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { convertQueryParams } from '~/messageRepository/utils';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class MessagePaginationController extends PaginationController<
+  'message',
+  Amity.MessagesLiveCollection
+> {
+  async getRequest(queryParams: Amity.MessagesLiveCollection, token: string | undefined) {
+    const processedQueryParams = convertQueryParams(queryParams);
+    const { data: queryResponse } = await this.http.get<Amity.MessagePayload & Amity.Pagination>(
+      `/api/v5/messages`,
+      {
+        params: {
+          ...processedQueryParams,
+          options: token
+            ? {
+                token,
+              }
+            : {
+                ...processedQueryParams.options,
+              },
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/messageRepository/observers/getMessages/MessageQueryStreamController.ts

@@ -0,0 +1,141 @@
+/* eslint-disable no-use-before-define */
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+import { MessagePaginationController } from './MessagePaginationController';
+import { getMessageIdentifierIds } from '~/messageRepository/utils';
+
+export class MessageQueryStreamController extends QueryStreamController<
+  Amity.MessagePayload,
+  Amity.MessagesLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.MessagePayload,
+  ) => Promise<Amity.ProcessedMessagePayload>;
+
+  private paginationController: MessagePaginationController;
+
+  constructor(
+    query: Amity.MessagesLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.MessagePayload) => Promise<Amity.ProcessedMessagePayload>,
+    paginationController: MessagePaginationController,
+  ) {
+    super(query, cacheKey);
+
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+    this.paginationController = paginationController;
+  }
+
+  async saveToMainDB(response: Amity.MessagePayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.MessagePayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: getMessageIdentifierIds(response.messages),
+        query: this.query,
+      });
+    } else {
+      const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+
+      const messages = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data:
+          direction === 'next'
+            ? [...new Set([...messages, ...getMessageIdentifierIds(response.messages)])]
+            : [...new Set([...getMessageIdentifierIds(response.messages), ...messages])],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (payload: Amity.InternalMessage) => {
+      if (action === 'onCreate') {
+        const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+        const { referenceId } = payload;
+
+        if (!collection) return;
+        if (this.query.subChannelId !== payload?.subChannelId || !collection) return;
+
+        if (this.query.type && this.query.type !== payload.dataType) return;
+
+        if (this.query.dataType && this.query.dataType !== payload.dataType) return;
+
+        if (
+          this.query.excludingTags &&
+          this.query.excludingTags?.some(value => payload.tags?.includes(value))
+        )
+          return;
+
+        if (
+          this.query.excludeTags &&
+          this.query.excludeTags?.some(value => payload.tags?.includes(value))
+        )
+          return;
+        if (!!this.query.hasFlags !== !!payload.flagCount) return;
+
+        if (this.query.parentId && this.query.parentId !== payload.parentId) return;
+
+        if (
+          this.query.hasOwnProperty('includeDeleted') &&
+          !this.query.includeDeleted &&
+          payload.isDeleted
+        )
+          return;
+
+        if (
+          this.query.includingTags &&
+          !this.query.includingTags?.some(value => payload.tags?.includes(value))
+        )
+          return;
+
+        if (this.query.tags && !this.query.tags?.some(value => payload.tags?.includes(value)))
+          return;
+
+        if (
+          (!this.query.sortBy || this.query.sortBy === 'segmentDesc') &&
+          !this.paginationController.getPrevToken()
+        ) {
+          collection.data = [...new Set([referenceId ?? payload.messageId, ...collection.data])];
+        }
+
+        if (this.query.sortBy === 'segmentAsc' && !this.paginationController.getNextToken()) {
+          collection.data = [...new Set([...collection.data, referenceId ?? payload.messageId])];
+        }
+
+        pushToCache(this.cacheKey, collection);
+      }
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.InternalMessage>) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/messageRepository/observers/getMessages/getMessages.ts

@@ -0,0 +1,110 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { filterByPropEquality } from '~/core/query';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { MessageLiveCollectionController } from './MessageLiveCollectionController';
+
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.Message>(
+  data: T[],
+  params: Amity.MessagesLiveCollection,
+): T[] => {
+  let messages = data;
+
+  messages = messages.filter(m => {
+    if (params.tags) {
+      return params.tags.find(value => {
+        if (!m.tags) return false;
+        return m.tags.includes(value);
+      });
+    }
+    return true;
+  });
+
+  messages = messages.filter(m => {
+    if (params.excludeTags) {
+      return (params.excludeTags || []).find(value => {
+        if (!m.tags) return true;
+        return !m.tags.includes(value);
+      });
+    }
+    return true;
+  });
+
+  /*
+   * for cases when message is deleted via RTE, this flag is used to get
+   * items from cache that are !deleted
+   */
+  if (!params.includeDeleted) {
+    messages = filterByPropEquality(messages, 'isDeleted', false);
+  }
+
+  messages = messages.sort((message1, message2) => {
+    if (params.sortBy === 'segmentAsc') {
+      return message1.channelSegment - message2.channelSegment;
+    }
+    if (params.sortBy === 'segmentDesc') {
+      return message2.channelSegment - message1.channelSegment;
+    }
+    return 0;
+  });
+
+  return messages;
+};
+
+/* begin_public_function
+  id: message.query
+*/
+/**
+ * ```js
+ * import { getMessages } from '@amityco/ts-sdk';
+ *
+ * let messages = [];
+ *
+ * const unsubscribe = getMessages({
+ *   subChannelId: Amity.SubChannel['subChannelId'];
+ * }, response => merge(messages, response.data));
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Message} for a given target object
+ *
+ * @param params for querying messages from a sub channel
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Messages Live Collection
+ */
+export const getMessages = (
+  params: Amity.MessagesLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Message>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getMessages(tmpid: ${timestamp}) > listen`);
+
+  const messagesLiveCollection = new MessageLiveCollectionController(params, callback);
+  const disposers = messagesLiveCollection.startSubscription();
+
+  const cacheKey = messagesLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`getMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/messageRepository/observers/getMessages/index.ts

@@ -0,0 +1 @@
+export * from './getMessages';

package/src/messageRepository/observers/index.ts

@@ -0,0 +1,5 @@
+export { getMessage } from './getMessage';
+export { getMessages } from './getMessages';
+
+export { observeMessage } from './observeMessage';
+export { observeMessages } from './observeMessages';

package/src/messageRepository/observers/observeMessage.ts

@@ -0,0 +1,94 @@
+import { getActiveClient } from '~/client/api';
+
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
+import { convertEventPayload } from '~/utils/event';
+
+import { getMessage } from '../api/getMessage';
+
+import { onMessageUpdated, onMessageDeleted } from '../events';
+import { LinkedObject } from '~/utils/linkedObject';
+
+/**
+ * ```js
+ * import { observeMessage } from '@amityco/ts-sdk'
+ *
+ * let message = {}
+ *
+ * const unsub = observeMessage(messageId, updated => message = updated)
+ * ```
+ *
+ * Observe all mutations on a {@link Amity.Message} given a single messageId
+ *
+ * @param client the client to observe the message with
+ * @param messageId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @param policy a query policy option for this observer
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the message
+ *
+ * @category Message Observer
+ */
+export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
+  messageId: Amity.Message['messageId'],
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeMessage(tmpid: ${timestamp}) > listen`);
+
+  console.log(
+    'observeMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+  );
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Message>, action: Events[number]) => {
+    // filter function
+    if (result.data?.messageId !== messageId) return;
+
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onMessageUpdated(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+    onMessageDeleted(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onDelete'),
+    ),
+    convertEventPayload(
+      onMessageMarkerFetched,
+      'contentId',
+      'message',
+    )(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+    convertEventPayload(
+      onMessageMarked,
+      'contentId',
+      'message',
+    )(data =>
+      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+  );
+
+  if (policy !== 'no_fetch') {
+    runQuery(
+      createQuery(getMessage, messageId),
+      result => result.data && router(result, 'onFetch'),
+      queryOptions(policy),
+    );
+  }
+
+  return () => {
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};