@amityco/ts-sdk 6.35.2 → 6.35.3-024c022.0

package/src/messageRepository/api/getMessage.ts

@@ -1,102 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/**
- * ```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.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: LinkedObject.message(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/messageRepository/api/getMessages.ts

@@ -1,83 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/**
- * ```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);
-
-  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.map(message => LinkedObject.message(message)),
-    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/messageRepository/observers/observeMessage.ts

@@ -1,94 +0,0 @@
-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());
-  };
-};

package/src/messageRepository/observers/observeMessages.ts

@@ -1,89 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
-import { convertEventPayload } from '~/utils/event';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import {
-  onMessageCreatedLocal,
-  onMessageCreatedMqtt,
-  onMessageDeleted,
-  onMessageUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { observeMessages } from '@amityco/ts-sdk'
- *
- * let messages = []
- *
- * const unsubscribe = observeMessages(channelId, message => merge(messages, message))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.SubChannel} object
- *
- * @param subChannelId the ID of the channel where to observe the messages
- * @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 Message Observer
- */
-export const observeMessages = (
-  subChannelId: Amity.SubChannel['subChannelId'],
-  callback: Amity.ObjectListener<
-    Amity.Snapshot<Amity.Message>,
-    ['onCreate', 'onUpdate', 'onDelete']
-  >,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observeMessages(tmpid: ${timestamp}) > listen`);
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const router = (
-    message: Amity.Snapshot<Amity.Message>,
-    action: 'onCreate' | 'onUpdate' | 'onDelete',
-  ) => {
-    if (message.data?.subChannelId !== subChannelId) return;
-
-    if (callback instanceof Function) return callback(message);
-
-    callback.onEvent?.(action, message);
-    callback[action]?.(message);
-  };
-
-  disposers.push(
-    onMessageCreatedMqtt(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-    onMessageCreatedLocal(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-    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' }, 'onCreate'),
-    ),
-    convertEventPayload(
-      onMessageMarked,
-      'contentId',
-      'message',
-    )(data =>
-      router({ data: LinkedObject.message(data), loading: false, origin: 'event' }, 'onCreate'),
-    ),
-  );
-
-  return () => {
-    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/pollRepository/observers/observePoll.ts

@@ -1,67 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { createQuery, runQuery, queryOptions } from '~/core/query';
-
-import { getPoll as _getPoll } from '../api/getPoll';
-
-import { onPollUpdated, onPollDeleted } from '../events';
-
-/**
- * ```js
- * import { observePoll } from '@amityco/ts-sdk'
- *
- * let poll = {}
- * const dispose = observePoll(pollId, updated => poll = updated)
- * ```
- *
- * Observe all mutation on a given {@link Amity.Poll}
- *
- * @param pollId the ID of the poll 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 poll
- *
- * @category Poll Observer
- */
-export const observePoll = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
-  pollId: string,
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Poll | undefined>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server',
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observePoll(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.Poll | undefined>, action: Events[number]) => {
-    if (callback instanceof Function) return callback(result);
-
-    if (action !== 'onFetch') callback.onEvent?.(action, result);
-
-    callback[action]?.(result);
-  };
-
-  const realtimeRouter = (result: Amity.Snapshot<Amity.Poll>, action: Events[number]) => {
-    if (result.data?.pollId !== pollId) return;
-
-    router(result, action);
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onPollUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onPollDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
-  );
-
-  runQuery(
-    createQuery(_getPoll, pollId),
-    result => (result.data || result.error) && router(result, 'onFetch'),
-    queryOptions(policy),
-  );
-
-  return () => {
-    log(`observePoll(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/postRepository/api/updatePost.ts

@@ -1,63 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: post.edit
-*/
-/**
- * ```js
- * import { updatePost } from '@amityco/ts-sdk'
- * const updated = await updatePost(postId, {
- *   data: { text: 'hello world' }
- * })
- * ```
- *
- * Updates an {@link Amity.Post}
- *
- * @param postId The ID of the {@link Amity.Post} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Post} object
- *
- * @category Post API
- * @async
- */
-export const updatePost = async <T extends Amity.PostContentType>(
-  postId: Amity.Post['postId'],
-  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'> & {
-    attachments?: {
-      type: T;
-      fileId: Amity.File['fileId'];
-    }[];
-  },
-): Promise<Amity.Cached<Amity.Post>> => {
-  const client = getActiveClient();
-  client.log('user/updatePost', patch);
-
-  console.warn(
-    'Deprecation: updatePost has been renamed to editPost. Update post API will be deprecated soon.',
-  );
-
-  const { data: payload } = await client.http.put<Amity.PostPayload>(
-    `/api/v4/posts/${encodeURIComponent(postId)}`,
-    patch,
-  );
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  fireEvent('local.post.updated', payload);
-
-  const { posts } = data;
-
-  return {
-    data: LinkedObject.post(posts.find(post => post.postId === postId)!),
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/postRepository/observers/observePost.ts

@@ -1,115 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { createQuery, queryOptions, runQuery } from '~/core/query';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { getPost } from '../api/getPost';
-
-import {
-  onPostApproved,
-  onPostDeclined,
-  onPostDeleted,
-  onPostFlagged,
-  onPostReactionAdded,
-  onPostReactionRemoved,
-  onPostUnflagged,
-  onPostUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { observePost } from '@amityco/ts-sdk'
- *
- * let post = {}
- * const dispose = observePost(postId, updated => post = updated)
- * ```
- *
- * Observe all mutations on a given {@link Amity.Post}
- *
- * @param postId the ID of the post 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 post
- *
- * @category Post Observer
- */
-export const observePost = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onApproved',
-    'onDeclined',
-    'onFlagged',
-    'onUnflagged',
-    'onReactionAdded',
-    'onReactionRemoved',
-  ],
->(
-  postId: Amity.Post['postId'],
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Post | undefined>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server',
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observePost(tmpid: ${timestamp}) > listen`);
-
-  // wrapper function to make sure
-  const router = (result: Amity.Snapshot<Amity.Post | undefined>, action: Events[number]) => {
-    if (callback instanceof Function) return callback(result);
-
-    if (action !== 'onFetch') callback.onEvent?.(action, result);
-
-    callback[action]?.(result);
-  };
-
-  const realtimeRouter = (result: Amity.Snapshot<Amity.InternalPost>, action: Events[number]) => {
-    if (result.data?.postId !== postId) return;
-
-    router(
-      {
-        ...result,
-        data: result.data && LinkedObject.post(result.data),
-      },
-      action,
-    );
-  };
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  disposers.push(
-    onPostUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onPostDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
-    onPostApproved(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onApproved')),
-    onPostDeclined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDeclined')),
-    onPostFlagged(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged')),
-    onPostUnflagged(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
-    ),
-    onPostReactionAdded(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
-    ),
-    onPostReactionRemoved(data =>
-      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
-    ),
-  );
-
-  runQuery(
-    createQuery(getPost, postId),
-    result =>
-      (result.data || result.error) &&
-      router(
-        {
-          ...result,
-          data: result.data && LinkedObject.post(result.data),
-        },
-        'onFetch',
-      ),
-    queryOptions(policy),
-  );
-
-  return () => {
-    log(`observePosts(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};

package/src/postRepository/observers/observePosts.ts

@@ -1,86 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { LinkedObject } from '~/utils/linkedObject';
-import {
-  onPostApproved,
-  onPostCreated,
-  onPostDeclined,
-  onPostDeleted,
-  onPostFlagged,
-  onPostReactionAdded,
-  onPostReactionRemoved,
-  onPostUnflagged,
-  onPostUpdated,
-} from '../events';
-
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- *
- * let posts = []
- * const unsub = PostRepository.observePosts({
- *   targetType: Amity.PostTargetType,
- *   targetId: Amity.InternalPost['targetId'],
- * }, post => merge(posts, post))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.Post} for a given target object
- *
- * @param params
- * @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 Post Observer
- */
-export const observePosts = (
-  params: {
-    targetType: Amity.PostTargetType;
-    targetId: Amity.Post['targetId'];
-  },
-  callback: Amity.ObjectListener<
-    Amity.Post,
-    [
-      'onCreate',
-      'onUpdate',
-      'onDelete',
-      'onApproved',
-      'onDeclined',
-      'onFlagged',
-      'onUnflagged',
-      'onReactionAdded',
-      'onReactionRemoved',
-    ]
-  >,
-): Amity.Unsubscriber => {
-  const { log } = getActiveClient();
-
-  const timestamp = Date.now();
-  log(`observePosts(tmpid: ${timestamp}) > listen`);
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const router = (post: Amity.InternalPost, action: Exclude<Amity.PostActionType, 'onFetch'>) => {
-    if (params.targetId !== post.targetId || params.targetType !== post.targetType) return;
-
-    if (callback instanceof Function) return callback(LinkedObject.post(post));
-
-    callback.onEvent?.(action, LinkedObject.post(post));
-    callback[action]?.(LinkedObject.post(post));
-  };
-
-  disposers.push(
-    onPostCreated(post => router(post, 'onCreate')),
-    onPostUpdated(post => router(post, 'onUpdate')),
-    onPostDeleted(post => router(post, 'onDelete')),
-    onPostApproved(post => router(post, 'onApproved')),
-    onPostDeclined(post => router(post, 'onDeclined')),
-    onPostFlagged(post => router(post, 'onFlagged')),
-    onPostUnflagged(post => router(post, 'onUnflagged')),
-    onPostReactionAdded(post => router(post, 'onReactionAdded')),
-    onPostReactionRemoved(post => router(post, 'onReactionRemoved')),
-  );
-
-  return () => {
-    log(`observePosts(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};