@amityco/ts-sdk 0.0.1-beta.42.3 → 0.0.1-beta.43

package/src/marker/api/tests/getChannelMarkers.test.ts

@@ -0,0 +1,109 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { onUserMarkerFetched } from '~/marker/events';
+import { onChannelMarkerFetched } from '~/marker/events/onChannelMarkerFetched';
+import { client, generateChannelMarker, generateUserMarker } from '~/utils/tests';
+
+import { getChannelMarkers } from '../getChannelMarkers';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const userId = 'user1';
+
+const expectedChannelMarkers = [
+  generateChannelMarker({ entityId: 'ch1', userId }),
+  generateChannelMarker({ entityId: 'ch2', userId }),
+];
+
+const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
+
+const channelIds = expectedChannelMarkers.map(({ entityId }) => entityId);
+
+const resolvedGetValue = {
+  data: {
+    userEntityMarkers: expectedChannelMarkers,
+    userMarkers: expectedUserMarkers,
+    paging: pagingToken,
+  },
+};
+
+describe('getChannelMarkers', () => {
+  it('should return channel markers', async () => {
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const { data } = await getChannelMarkers(channelIds);
+
+    expect(data).toEqual(expectedChannelMarkers);
+  });
+
+  test('should return fetched channel markers with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getChannelMarkers(channelIds, pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: expectedChannelMarkers,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching channelMarkers ', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getChannelMarkers(channelIds);
+    const cacheKeyResolver = getResolver('channelMarker');
+
+    const received = channelIds.map(
+      entityId =>
+        pullFromCache(['channelMarker', 'get', cacheKeyResolver({ entityId, userId })])?.data,
+    );
+
+    expect(received).toEqual(expectedChannelMarkers);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('Not Found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannelMarkers(channelIds)).rejects.toThrow('Amity SDK (400400): Not Found');
+  });
+
+  test('should fire event `onChannelMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onChannelMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getChannelMarkers(channelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedChannelMarkers[0]);
+  });
+
+  test('should fire event `onUserMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getChannelMarkers(channelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedUserMarkers[0]);
+  });
+});

package/src/marker/api/tests/getMessageMarkers.test.ts

@@ -0,0 +1,114 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { onMessageMarkerFetched, onUserMarkerFetched } from '~/marker/events';
+import {
+  client,
+  generateFeedMarker,
+  generateMessageMarker,
+  generateUserMarker,
+} from '~/utils/tests';
+
+import { getMessageMarkers } from '../getMessageMarkers';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const expectedMessageMarkers = [
+  generateMessageMarker({ feedId: 'sub-ch1', contentId: 'message1' }),
+  generateMessageMarker({ feedId: 'sub-ch1', contentId: 'message2' }),
+];
+
+const expectedFeedMarkers = [generateFeedMarker({ feedId: 'sub-ch1', entityId: 'feed1' })];
+
+const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
+
+const messageIds = expectedMessageMarkers.map(({ contentId }) => contentId);
+const messageMarkerResolver = getResolver('messageMarker');
+const messageMarkerCacheIds = expectedMessageMarkers.map(messageMarkerResolver);
+
+const resolvedGetValue = {
+  data: {
+    contentMarkers: expectedMessageMarkers,
+    feedMarkers: expectedFeedMarkers,
+    userMarkers: expectedUserMarkers,
+    paging: pagingToken,
+  } as Amity.MessageMarkerPayload,
+};
+
+describe('getMessageMarkers', () => {
+  it('should return message markers', async () => {
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const { data } = await getMessageMarkers(messageIds);
+
+    expect(data).toEqual(expectedMessageMarkers);
+  });
+
+  test('should return fetched message markers with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getMessageMarkers(messageIds, pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: expectedMessageMarkers,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching message markers ', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getMessageMarkers(messageIds);
+    const received = messageMarkerCacheIds.map(
+      id => pullFromCache(['messageMarker', 'get', id])?.data,
+    );
+
+    expect(received).toEqual(expectedMessageMarkers);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('Not Found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getMessageMarkers(messageIds)).rejects.toThrow('Amity SDK (400400): Not Found');
+  });
+
+  test('should fire event `onMessageMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getMessageMarkers(messageIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedMessageMarkers[0]);
+  });
+
+  test('should fire event `onUserMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getMessageMarkers(messageIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedUserMarkers[0]);
+  });
+});

package/src/marker/api/tests/getSubChannelMarkers.test.ts

@@ -0,0 +1,116 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { onSubChannelMarkerFetched, onUserMarkerFetched } from '~/marker/events';
+import {
+  client,
+  generateChannelMarker,
+  generateSubChannelMarker,
+  generateUserMarker,
+} from '~/utils/tests';
+
+import { getSubChannelMarkers } from '../getSubChannelMarkers';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const expectedSubChannelMarkers = [
+  generateSubChannelMarker({ feedId: 'sub-ch1', entityId: 'ch1' }),
+  generateSubChannelMarker({ feedId: 'sub-ch2', entityId: 'ch1' }),
+];
+
+const expectedChannelMarkers = [generateChannelMarker({ entityId: 'ch1', userId: 'user1' })];
+
+const expectedUserMarkers = [generateUserMarker({ userId: 'currentUser1' })];
+
+const subChannelIds = expectedSubChannelMarkers.map(({ feedId }) => feedId);
+const subChannelMarkerResolver = getResolver('subChannelMarker');
+const subChannelMarkerCacheIds = expectedSubChannelMarkers.map(subChannelMarkerResolver);
+
+const resolvedGetValue = {
+  data: {
+    userFeedMarkers: expectedSubChannelMarkers,
+    userEntityMarkers: expectedChannelMarkers,
+    userMarkers: expectedUserMarkers,
+    paging: pagingToken,
+  } as Amity.SubChannelMarkerPayload,
+};
+
+describe('getSubChannelMarkers', () => {
+  it('should return sub channel markers', async () => {
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const { data } = await getSubChannelMarkers(subChannelIds);
+
+    expect(data).toEqual(expectedSubChannelMarkers);
+  });
+
+  test('should return fetched sub channel markers with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getSubChannelMarkers(subChannelIds, pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: expectedSubChannelMarkers,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching sub channel markers ', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getSubChannelMarkers(subChannelIds);
+    const received = subChannelMarkerCacheIds.map(
+      id => pullFromCache(['subChannelMarker', 'get', id])?.data,
+    );
+
+    expect(received).toEqual(expectedSubChannelMarkers);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('Not Found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getSubChannelMarkers(subChannelIds)).rejects.toThrow(
+      'Amity SDK (400400): Not Found',
+    );
+  });
+
+  test('should fire event `onSubChannelMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onSubChannelMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getSubChannelMarkers(subChannelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedSubChannelMarkers[0]);
+  });
+
+  test('should fire event `onUserMarkerFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserMarkerFetched(resolve);
+    }).finally(dispose);
+
+    await getSubChannelMarkers(subChannelIds);
+
+    await expect(callbackPromise).resolves.toMatchObject(expectedUserMarkers[0]);
+  });
+});

package/src/marker/events/index.ts

@@ -0,0 +1,10 @@
+export * from './onChannelMarkerFetched';
+
+export * from './onSubChannelMarkerFetched';
+export * from './onSubChannelMarkerUpdated';
+
+export * from './onFeedlMarkerFetched';
+
+export * from './onUserMarkerFetched';
+
+export * from './onMessageMarkerFetched';

package/src/marker/events/onChannelMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onChannelMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onChannelMarkerFetched(channelMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.ChannelMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category ChannelMarker Events
+ */
+export const onChannelMarkerFetched = (
+  callback: Amity.Listener<Amity.ChannelMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.channelMarker.fetched']) => {
+    callback(payload.userEntityMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'channelMarker/onChannelMarkerFetched',
+    'local.channelMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onFeedlMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onFeedMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerFetched(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.FeedMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+export const onFeedMarkerFetched = (
+  callback: Amity.Listener<Amity.FeedMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.feedMarker.fetched']) => {
+    callback(payload.feedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'feedMarker/onFeedMarkerFetched',
+    'local.feedMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onMessageMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onMessageMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onMessageMarkerFetched(messageMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.MessageMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category MessageMarker Events
+ */
+export const onMessageMarkerFetched = (
+  callback: Amity.Listener<Amity.MessageMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.messageMarker.fetched']) => {
+    callback(payload.contentMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'messageMarker/onMessageMarkerFetched',
+    'local.messageMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onSubChannelMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelMarkerFetched(subChannelMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.SubChannelMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category SubChannelMarker Events
+ */
+export const onSubChannelMarkerFetched = (
+  callback: Amity.Listener<Amity.SubChannelMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.subChannelMarker.fetched']) => {
+    callback(payload.userFeedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'subChannelMarker/onSubChannelMarkerFetched',
+    'local.subChannelMarker.fetched',
+    filter,
+  );
+};

package/src/marker/events/onSubChannelMarkerUpdated.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onSubChannelMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onSubChannelMarkerUpdated(subChannelMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.SubChannelMarker} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category SubChannelMarker Events
+ */
+export const onSubChannelMarkerUpdated = (
+  callback: Amity.Listener<Amity.SubChannelMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.subChannelMarker.updated']) => {
+    callback(payload.userFeedMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'subChannelMarker/onSubChannelMarkerUpdated',
+    'local.subChannelMarker.updated',
+    filter,
+  );
+};

package/src/marker/events/onUserMarkerFetched.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onUserMarkerFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserMarkerFetched(userMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMarker} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category UserMarker Events
+ */
+export const onUserMarkerFetched = (
+  callback: Amity.Listener<Amity.UserMarker>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.userMarker.fetched']) => {
+    callback(payload.userMarkers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'userMarker/onUserMarkerFetched',
+    'local.userMarker.fetched',
+    filter,
+  );
+};

package/src/message/api/createMessage.ts

@@ -68,7 +68,7 @@ export const createMessage = async <T extends Amity.MessageContentType>(
     referenceId,
   });
 
-  const data = prepareMessagePayload(payload);
+  const data = await prepareMessagePayload(payload);
   const { messages } = data;
 
   const cachedAt = client.cache && Date.now();

package/src/message/api/getMessage.ts

@@ -7,7 +7,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { convertResponseFromRaw } from '../utils';
+
+import { prepareMessagePayload } from '../utils';
 
 /* begin_public_function
   id: message.get
@@ -45,11 +46,11 @@ export const getMessage = async (
 
   try {
     // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const response = await client.http
-      .get<Amity.MessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
-      .then(convertResponseFromRaw);
+    const { data: payload } = await client.http.get<Amity.MessagePayload>(
+      `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    );
 
-    data = response.data;
+    data = await prepareMessagePayload(payload);
   } catch (error) {
     if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
       pushToTombstone('message', messageId);

package/src/message/api/getMessages.ts

@@ -3,7 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { fireEvent } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { convertResponseFromRaw } from '../utils';
+
+import { prepareMessagePayload } from '../utils';
 
 /**
  * ```js
@@ -25,11 +26,11 @@ export const getMessages = async (
   const client = getActiveClient();
   client.log('message/getMessages', messageIds);
 
-  const { data } = await client.http
-    .get<Amity.MessagePayload>(`/api/v5/messages/list`, {
-      params: { messageIds: messageIds.map(encodeURIComponent) },
-    })
-    .then(convertResponseFromRaw);
+  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 });

package/src/message/api/index.ts

@@ -4,3 +4,4 @@ export * from './queryMessages';
 export * from './createMessage';
 export * from './updateMessage';
 export * from './deleteMessage';
+export * from './markAsDelivered';

package/src/message/api/markAsDelivered.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { markAsDelivered } from '@amityco/ts-sdk'
+ * const success = await markAsDelivered('subChannelId', 'messageId')
+ * ```
+ *
+ * Update `deliveredToSegment` in  {@link Amity.SubChannelMarker}
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} of message
+ * @param messageId the ID of the {@link Amity.Message} to mark delivered
+ * @returns A success boolean if the {@link Amity.SubChannel} was updated
+ *
+ * @category Message API
+ * @async
+ */
+export const markAsDelivered = async (
+  subChannelId: Amity.Message['subChannelId'],
+  messageId: Amity.Message['messageId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/markAsDelivered', subChannelId, messageId);
+
+  const { data } = await client.http.put<Amity.MarkDeliveredPayload>(
+    `/api/v1/markers/message-feeds/${subChannelId}/mark-delivering`,
+    { messageId },
+  );
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return true;
+};