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

package/src/reaction/api/tests/addReaction.test.ts

@@ -1,21 +1,56 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
 import { onMessageUpdated } from '~/message/events';
 import { addReaction } from '~/reaction/api';
+
 import { client, message11 as message, pause } from '~/utils/tests';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+
+const cacheKey = ['message', 'get', message.messageId];
 
 describe('addReaction', () => {
-  const cacheKey = ['message', 'get', message.messageId];
+  test('it should add a reaction', async () => {
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
 
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('addReaction > optimistically', () => {
   beforeEach(enableCache);
 
   afterEach(disableCache);
 
-  test('should optimistically add a reaction', async () => {
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(addReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically add a reaction', async () => {
     const callback = jest.fn();
     pushToCache(cacheKey, message);
     onMessageUpdated(callback);
 
-    const success = await addReaction.optimistically('message', message.messageId, 'like');
+    const success = addReaction.optimistically('message', message.messageId, 'like');
 
     expect(success).toEqual(true);
     expect(pullFromCache(cacheKey)?.data).toMatchObject({
@@ -27,11 +62,12 @@ describe('addReaction', () => {
     expect(callback).toBeCalledTimes(1);
   });
 
-  test('should add a reaction', async () => {
-    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+  test('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
 
-    const success = await addReaction('message', message.messageId, 'like');
+    const success = addReaction.optimistically('message', message.messageId, 'like');
 
     expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
   });
 });

package/src/reaction/api/tests/removeReaction.test.ts

@@ -1,27 +1,62 @@
 import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
 import { onMessageUpdated } from '~/message/events';
 import { removeReaction } from '~/reaction/api';
-import { client, message11 as message, message11, pause } from '~/utils/tests';
+
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { client, message11, pause } from '~/utils/tests';
+
+const message = {
+  ...message11,
+  myReactions: ['like'],
+  reactions: { like: 1 },
+  reactionsCount: 1,
+};
+const cacheKey = ['message', 'get', message.messageId];
 
 describe('removeReaction', () => {
-  const message = {
-    ...message11,
-    myReactions: ['like'],
-    reactions: { like: 1 },
-    reactionsCount: 1,
-  };
-  const cacheKey = ['message', 'get', message.messageId];
+  test('it should remove a reaction', async () => {
+    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
 
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('removeReaction > optimistically', () => {
   beforeEach(enableCache);
 
   afterEach(disableCache);
 
-  test('should optimistically add a reaction', async () => {
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(removeReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically remove a reaction', async () => {
     const callback = jest.fn();
     pushToCache(cacheKey, message);
     onMessageUpdated(callback);
 
-    const success = await removeReaction.optimistically('message', message.messageId, 'like');
+    const success = removeReaction.optimistically('message', message.messageId, 'like');
 
     expect(success).toEqual(true);
     expect(pullFromCache(cacheKey)?.data).toMatchObject({
@@ -33,11 +68,12 @@ describe('removeReaction', () => {
     expect(callback).toBeCalledTimes(1);
   });
 
-  test('should add a reaction', async () => {
-    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
+  test('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
 
-    const success = await removeReaction('message', message.messageId, 'like');
+    const success = removeReaction.optimistically('message', message.messageId, 'like');
 
     expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
   });
 });

package/src/reaction/events/onReactionAdded.ts

@@ -5,6 +5,7 @@ import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { onPostReactionAdded } from '~/post/events';
 import { onCommentReactionAdded } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -41,7 +42,8 @@ export const onReactionAdded = (
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',
@@ -56,12 +58,7 @@ export const onReactionAdded = (
       }
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactionAdded',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactionAdded', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/events/onReactionRemoved.ts

@@ -5,6 +5,7 @@ import { createEventSubscriber } from '~/core/events';
 import { getResolver } from '~/core/model';
 import { onPostReactionRemoved } from '~/post/events';
 import { onCommentReactionRemoved } from '~/comment/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -37,7 +38,8 @@ export const onReactionRemoved = (
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',
@@ -52,12 +54,7 @@ export const onReactionRemoved = (
       }
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactionRemoved',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactionRemoved', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/events/onReactorAdded.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 onReactorAdded = (
   };
 
   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, userDisplayName, ...reactor } =
@@ -51,7 +53,7 @@ export const onReactorAdded = (
       callbackWrapper('message', payload.messages[0].messageId, reactor);
     };
 
-    return createEventSubscriber(client, 'reaction/onReactorAdded', 'v3.message.didUpdate', filter);
+    return createEventSubscriber(client, 'reaction/onReactorAdded', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

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,
+  };
+};