@amityco/ts-sdk 0.0.1-beta.33 → 0.0.1-beta.36

package/src/reaction/events/onReactorRemoved.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -37,7 +38,8 @@ export const onReactorRemoved = (
   };
 
   if (referenceType === 'message') {
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       if (!payload.messages[0].latestReaction) return;
 
       const { eventName, referenceId, referenceType, ...reactor } =
@@ -51,12 +53,7 @@ export const onReactorRemoved = (
       callbackWrapper('message', payload.messages[0].messageId, reactor);
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactorRemoved',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactorRemoved', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/observers/liveReactions.ts

@@ -74,7 +74,7 @@ export const liveReactions = (
     });
   };
 
-  const realtimeRouter = (reaction: Amity.Reactor, action: Amity.ReactionActionType) => {
+  const realtimeRouter = (action: Amity.ReactionActionType) => (reaction: Amity.Reactor) => {
     const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
     if (!collection) return;
 
@@ -125,11 +125,11 @@ export const liveReactions = (
   };
 
   disposers.push(
-    onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction =>
-      realtimeRouter(reaction, 'onAdded'),
-    ),
-    onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction =>
-      realtimeRouter(reaction, 'onRemoved'),
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')),
+    onReactorRemoved(
+      queryParams.referenceType,
+      queryParams.referenceId,
+      realtimeRouter('onRemoved'),
     ),
   );
 

package/src/reaction/utils/dispatchReactable.ts

@@ -7,7 +7,7 @@ export const dispatchReactable = <T extends Amity.ReactableType>(
 ) => {
   if (referenceType === 'message')
     // @ts-ignore: refactor later
-    fireEvent('v3.message.didUpdate', { messages: [model] });
+    fireEvent('local.message.updated', { messages: [model] });
   else if (referenceType === 'post')
     // @ts-ignore: refactor later
     fireEvent('post.updated', { posts: [model] });

package/src/report/api/createReport.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { prepareMessagePayload } from '~/message/utils';
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
@@ -25,26 +26,35 @@ export const createReport = async (
   const client = getActiveClient();
   client.log('report/createReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType];
+  const getAPIUrl = (): string => {
+    if (referenceType === 'user') {
+      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+    }
+
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
+
+    const { domainName } = REFERENCE_TYPES[referenceType];
+
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
+  };
 
   const { data } = await client.http.post<
-    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(
-    `/api/${
-      referenceType === 'user'
-        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
-        : `v3/${domainName}/${encodeURIComponent(referenceId)}/flag`
-    }`,
-  );
-
-  if (client.cache) ingestInCache(data);
-
-  const event =
-    referenceType === 'message'
-      ? ('v3.message.didUpdate' as const)
-      : (`${referenceType}.flagged` as const);
-
-  fireEvent(event, data);
+    Amity.PostPayload | Amity.CommentPayload | Amity.RawMessagePayload | Amity.UserPayload
+  >(getAPIUrl());
+
+  if (client.cache)
+    ingestInCache(
+      referenceType === 'message' ? prepareMessagePayload(data as Amity.RawMessagePayload) : data,
+    );
+
+  if (referenceType === 'message') {
+    fireEvent('message.flagged', data as Amity.RawMessagePayload);
+  } else {
+    // @ts-ignore
+    fireEvent(`${referenceType}.flagged`, data);
+  }
 
   return !!data;
 };

package/src/report/api/deleteReport.ts

@@ -2,8 +2,9 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import REFERENCE_TYPES from '../constants/referenceTypes';
 import { fireEvent } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
  * ```js
@@ -25,26 +26,35 @@ export const deleteReport = async (
   const client = getActiveClient();
   client.log('report/deleteReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType];
+  const getAPIUrl = (): string => {
+    if (referenceType === 'user') {
+      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+    }
+
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
+
+    const { domainName } = REFERENCE_TYPES[referenceType];
+
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
+  };
 
   const { data } = await client.http.delete<
     Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(
-    `/api/${
-      referenceType === 'user'
-        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
-        : `v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`
-    }`,
-  );
-
-  if (client.cache) ingestInCache(data);
-
-  const event =
-    referenceType === 'message'
-      ? ('v3.message.didUpdate' as const)
-      : (`${referenceType}.unflagged` as const);
-
-  fireEvent(event, data);
+  >(getAPIUrl());
+
+  if (client.cache)
+    ingestInCache(
+      referenceType === 'message' ? prepareMessagePayload(data as Amity.RawMessagePayload) : data,
+    );
+
+  if (referenceType === 'message') {
+    fireEvent('message.unflagged', data as Amity.RawMessagePayload);
+  } else {
+    // @ts-ignore
+    fireEvent(`${referenceType}.unflagged`, data);
+  }
 
   return !!data;
 };

package/src/report/api/isReportedByMe.ts

@@ -1,6 +1,5 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { synchronousWSCall } from '~/core/transports';
-
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
@@ -19,12 +18,20 @@ import REFERENCE_TYPES from '../constants/referenceTypes';
 export const isReportedByMe = async (
   referenceType: keyof typeof REFERENCE_TYPES,
   referenceId: string,
-) => {
+): Promise<boolean> => {
   const client = getActiveClient();
   client.log('report/isReportedByMe', { referenceType, referenceId });
 
   const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
 
+  if (referenceType === 'message') {
+    const { data } = await client.http.get<{ result: boolean }>(
+      `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+    );
+
+    return data.result;
+  }
+
   const { result, isFlagByMe } =
     (await synchronousWSCall<{
       result?: boolean;

package/src/subChannel/api/createSubChannel.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { createSubChannel } from '@amityco/ts-sdk'
+ * const created = await createSubChannel({ channelId: 'foobar', name: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.SubChannel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.SubChannel}
+ * @returns The newly created {@link Amity.SubChannel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const createSubChannel = async <T extends Amity.ChannelType>(
+  bundle: Pick<Amity.SubChannel, 'channelId' | 'displayName'>,
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('user/createSubChannel', bundle);
+
+  const response = await client.http.post<Amity.RawSubChannelPayload>('/api/v5/message-feeds', {
+    channelId: bundle.channelId,
+    name: bundle.displayName,
+  });
+  const data = prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('message-feed.created', response.data);
+
+  return {
+    data: data.messageFeeds[0],
+    cachedAt,
+  };
+};

package/src/subChannel/api/deleteSubChannel.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+import { getFutureDate } from '~/core/model';
+import { getSubChannel } from './getSubChannel';
+
+/**
+ * ```js
+ * import { deleteSubChannel } from '@amityco/ts-sdk'
+ * const success = await deleteSubChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.SubChannel}
+ *
+ * @param subChannelId The {@link Amity.SubChannel} ID to delete
+ * @return A success boolean if the {@link Amity.SubChannel} was deleted
+ *
+ * @category Channel API
+ * @async
+ */
+export const deleteSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  permanent = false,
+): Promise<Amity.SubChannel> => {
+  const client = getActiveClient();
+  client.log('channel/deleteSubChannel', subChannelId);
+
+  const subChannel = await getSubChannel(subChannelId);
+
+  await client.http.delete<{ success: boolean }>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { params: { permanent } },
+  );
+
+  const deleted = {
+    ...subChannel.data,
+    isDeleted: true,
+    updatedAt: getFutureDate(subChannel.data.updatedAt),
+  };
+
+  if (permanent) {
+    setTimeout(() => {
+      pushToTombstone('subChannel', subChannelId);
+    }, 0);
+  } else {
+    upsertInCache(['subChannel', 'get', subChannelId], deleted);
+  }
+
+  fireEvent('local.message-feed.deleted', { messageFeeds: [deleted] });
+
+  return deleted;
+};

package/src/subChannel/api/getSubChannel.ts

@@ -0,0 +1,85 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = await getSubChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const getSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannel', subChannelId);
+
+  isInTombstone('subChannel', subChannelId);
+
+  try {
+    const response = await client.http.get<Amity.RawSubChannelPayload>(
+      `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    );
+    const data = prepareSubChannelPayload(response.data);
+
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) ingestInCache(data, { cachedAt });
+
+    fireEvent('local.message-feed.fetched', data);
+
+    return {
+      data: data.messageFeeds[0],
+      cachedAt,
+    };
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('subChannel', subChannelId);
+    }
+
+    throw error;
+  }
+};
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = getSubChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object from cache
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ */
+getSubChannel.locally = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Amity.Cached<Amity.SubChannel> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannel.locally', subChannelId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/subChannel/api/getSubChannels.ts

@@ -0,0 +1,77 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await getSubChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const getSubChannels = async (
+  subChannelIds: Amity.SubChannel['subChannelId'][],
+): Promise<Amity.Cached<Amity.SubChannel[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannels', subChannelIds);
+
+  const response = await client.http.get<Amity.RawSubChannelPayload>('/api/v5/message-feeds/list', {
+    params: { messageFeedIds: subChannelIds.map(encodeURIComponent) },
+  });
+  const data = prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('local.message-feed.fetched', data);
+
+  return {
+    data: data.messageFeeds,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = getSubChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects from cache
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ */
+getSubChannels.locally = (
+  subChannelIds: Amity.SubChannel['subChannelId'][],
+): Amity.Cached<Amity.SubChannel[]> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannels.locally', subChannelIds);
+
+  if (!client.cache) return;
+
+  const cached = subChannelIds
+    .map(channelId => pullFromCache<Amity.SubChannel>(['subChannel', 'get', channelId])!)
+    .filter(Boolean);
+
+  if (cached?.length < subChannelIds.length) return;
+
+  const subChannels = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  return {
+    data: subChannels,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/subChannel/api/index.ts

@@ -0,0 +1,8 @@
+export * from './querySubChannels';
+export * from './getSubChannels';
+export * from './getSubChannel';
+// export * from './getSubChannelByCreator';
+
+export * from './createSubChannel';
+export * from './updateSubChannel';
+export * from './deleteSubChannel';

package/src/subChannel/api/querySubChannels.ts

@@ -0,0 +1,115 @@
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { getResolver } from '~/core/model';
+import { toPage, toToken } from '~/core/query';
+import { fireEvent } from '~/core/events';
+import { convertQueryParams, prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { querySubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await querySubChannels({ channelId: 'channelId' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.SubChannel} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const querySubChannels = async (
+  query: Amity.QuerySubChannels,
+): Promise<Amity.Cached<Amity.Paged<Amity.SubChannel>>> => {
+  const client = getActiveClient();
+  client.log('channel/querySubChannels', query);
+
+  const { page = { limit: 10 }, channelId, ...params } = convertQueryParams(query);
+
+  const response = await client.http.get<Amity.RawSubChannelPayload & Amity.Pagination>(
+    `/api/v5/message-feeds/channel/${channelId}`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = response.data;
+  const data = prepareSubChannelPayload(payload);
+  const subChannels = data.messageFeeds;
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data as Amity.SubChannelPayload, { cachedAt });
+
+    const cacheKey = [
+      'subChannel',
+      'query',
+      { channelId, ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { subChannels: subChannels.map(getResolver('subChannel')), paging });
+  }
+
+  fireEvent('local.message-feed.fetched', data);
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: subChannels, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { querySubChannels } from '@amityco/ts-sdk'
+ * const subChannels = querySubChannels.locally({ channelId: 'channelId' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.SubChannel} objects from cache
+ *
+ * @param query The query parameters
+ * @returns sub channels
+ *
+ * @category Channel API
+ */
+querySubChannels.locally = (
+  query: Parameters<typeof querySubChannels>[0],
+): Amity.Cached<Amity.Paged<Amity.SubChannel>> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/querySubChannels.locally', query);
+
+  // @ts-ignore
+  const { page = { limit: 10 }, channelId, ...params } = convertQueryParams(query) ?? {};
+
+  const cacheKey = [
+    'subChannel',
+    'query',
+    { channelId, ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        subChannels: Pick<Amity.SubChannel, 'subChannelId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.subChannels.length) return;
+
+  const subChannels: Amity.SubChannel[] = data.subChannels
+    .map(ck => pullFromCache<Amity.SubChannel>(['subChannel', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return subChannels.length === data?.subChannels?.length
+    ? { data: subChannels, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/subChannel/api/updateSubChannel.ts

@@ -0,0 +1,43 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { updateSubChannel } from '@amityco/ts-sdk'
+ * const updated = await updateSubChannel(subChannelId, { name: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.SubChannel}
+ *
+ * @param subChannelId The ID of the {@link Amity.SubChannel} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const updateSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  patch: Patch<Amity.SubChannel, 'displayName'>,
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('channel/updateSubChannel', subChannelId, patch);
+
+  const response = await client.http.put<Amity.RawSubChannelPayload>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { name: patch.displayName },
+  );
+  const data = prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('message-feed.updated', response.data);
+
+  return {
+    data: data.messageFeeds[0],
+    cachedAt,
+  };
+};

package/src/subChannel/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onSubChannelCreated';
+export * from './onSubChannelUpdated';
+export * from './onSubChannelDeleted';