@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/reaction/observers/liveReactions.ts

@@ -0,0 +1,142 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import { onReactorAdded, onReactorRemoved } from '../events';
+import { queryReactions } from '../api';
+
+/**
+ * ```js
+ * import { liveReactions } from '@amityco/ts-sdk'
+ *
+ * let reactions = []
+ * const unsub = liveReactions({
+ *   referenceId: Amity.Reaction['referenceId'],
+ *   referenceType: Amity.Reaction['referenceType'],
+ * }, response => merge(reactions, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Reaction} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @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 Reactions Live Collection
+ */
+export const liveReactions = (
+  params: Amity.ReactionLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Reactor>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveReactions(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'reaction',
+    'collection',
+    { referenceId: params.referenceId, referenceType: params.referenceType },
+  ];
+
+  const responder = (data: Amity.ReactionLiveCollectionCache) => {
+    const reactions: Amity.Reactor[] =
+      data.data
+        .map(reactorId => pullFromCache<Amity.Reactor>(['reaction', 'get', reactorId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: reactions,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.ReactionActionType) => (reaction: Amity.Reactor) => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    if (action === 'onAdded') {
+      collection.data = [...new Set([reaction.reactionId, ...collection.data])];
+    } else if (action === 'onRemoved') {
+      collection.data = collection.data.filter(p => p !== reaction.reactionId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
+
+    const reactions = collection?.data ?? [];
+
+    if (reactions.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryReactions, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: reactions,
+        };
+
+        if (result) {
+          data.data = [
+            ...new Set([...reactions, ...result[0].reactors.map(getResolver('reaction'))]),
+          ];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')),
+    onReactorRemoved(
+      queryParams.referenceType,
+      queryParams.referenceId,
+      realtimeRouter('onRemoved'),
+    ),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveReactions(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/reaction/utils/dispatchReactable.ts

@@ -3,11 +3,11 @@ import { fireEvent } from '~/core/events';
 /** @hidden */
 export const dispatchReactable = <T extends Amity.ReactableType>(
   referenceType: T,
-  model: Amity.Model[T],
+  model: Amity.Models[T],
 ) => {
   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/reaction/utils/fetchReference.ts

@@ -6,7 +6,7 @@ import { getComment } from '~/comment/api';
 export const fetchReference = async (
   referenceType: Amity.ReactableType,
   referenceId: string,
-): Promise<Amity.Cached<Amity.Model[typeof referenceType]>> => {
+): Promise<Amity.Cached<Amity.Models[typeof referenceType]>> => {
   if (referenceType === 'message') return getMessage(referenceId);
   if (referenceType === 'post') return getPost(referenceId);
   if (referenceType === 'comment') return getComment(referenceId);

package/src/reaction/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './dispatchReactable';
 export * from './fetchReference';
 export * from './preparePayloadForCache';
+export * from './prepareMessagePayloadForCache';

package/src/reaction/utils/prepareMessagePayloadForCache.ts

@@ -0,0 +1,40 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+export const prepareMessagePayloadForCache = (payload: Amity.Message) => {
+  const client = getActiveClient();
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messageId]);
+  // '[]' in cases where the new reaction is the first one
+  const myReactions = cached?.data.myReactions || [];
+
+  // add myReactions to the payload
+  Object.assign(payload, { myReactions });
+
+  // check if there are any updates to the reactions
+  const latestReaction = payload?.latestReaction;
+  const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+
+  if (!isLatestReactionMine) {
+    return;
+  }
+
+  // new reaction added
+  if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: [...myReactions, latestReaction.reactionName],
+    });
+  }
+
+  // existing reaction removed
+  if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+    });
+  }
+};

package/src/report/api/createReport.ts

@@ -2,9 +2,14 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
+import { prepareMessagePayload } from '~/message/utils';
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
+/* begin_public_function
+  id: user.flag, message.flag, post.flag, comment.flag
+*/
 /**
  * ```js
  * import { createReport } from '@amityco/ts-sdk'
@@ -25,20 +30,36 @@ 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)}`;
+    }
 
-  const { data } = await client.http.post<
-    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`);
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
+
+    const { domainName } = REFERENCE_TYPES[referenceType];
 
-  if (client.cache) ingestInCache(data);
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
+  };
+
+  const { data: payload } = await client.http.post<
+    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
+  >(getAPIUrl());
 
-  const event =
-    referenceType === 'message'
-      ? ('v3.message.didUpdate' as const)
-      : (`${referenceType}.flagged` as const);
+  if (client.cache) {
+    if (referenceType === 'message') {
+      ingestInCache(prepareMessagePayload(payload as Amity.MessagePayload));
+    } else if (referenceType === 'post') {
+      ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
+    } else {
+      ingestInCache(payload as Amity.CommentPayload | Amity.UserPayload);
+    }
+  }
 
-  fireEvent(event, data);
+  fireEvent(`${referenceType}.flagged`, payload);
 
-  return !!data;
+  return !!payload;
 };
+/* end_public_function */

package/src/report/api/deleteReport.ts

@@ -2,9 +2,14 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import REFERENCE_TYPES from '../constants/referenceTypes';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+import { prepareMessagePayload } from '~/message/utils';
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
+/* begin_public_function
+  id: user.unflag, message.unflag, post.unflag, comment.unflag
+*/
 /**
  * ```js
  * import { deleteReport } from '@amityco/ts-sdk'
@@ -25,20 +30,37 @@ 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];
 
-  const { data } = await client.http.delete<
-    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(`/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`);
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
+  };
 
-  if (client.cache) ingestInCache(data);
+  const { data: payload } = await client.http.delete<
+    Amity.PostPayload | Amity.CommentPayload | Amity.ProcessedMessagePayload | Amity.UserPayload
+  >(getAPIUrl());
 
-  const event =
-    referenceType === 'message'
-      ? ('v3.message.didUpdate' as const)
-      : (`${referenceType}.unflagged` as const);
+  if (client.cache) {
+    if (referenceType === 'message') {
+      ingestInCache(prepareMessagePayload(payload as Amity.MessagePayload));
+    } else if (referenceType === 'post') {
+      ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
+    } else {
+      ingestInCache(payload as Amity.CommentPayload | Amity.UserPayload);
+    }
+  }
 
-  fireEvent(event, data);
+  // @ts-ignore
+  fireEvent(`${referenceType}.unflagged`, payload);
 
-  return !!data;
+  return !!payload;
 };
+/* end_public_function */

package/src/report/api/isReportedByMe.ts

@@ -1,8 +1,10 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { synchronousWSCall } from '~/core/transports';
-
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
+/* begin_public_function
+  id: user.check_flag_by_me, message.check_flag_by_me, post.check_flag_by_me, comment.check_flag_by_me
+*/
 /**
  * ```js
  * import { isReportedByMe } from '@amityco/ts-sdk'
@@ -19,12 +21,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;
@@ -35,3 +45,4 @@ export const isReportedByMe = async (
 
   return result ?? isFlagByMe ?? false;
 };
+/* end_public_function */

package/src/report/api/tests/createReport.test.ts

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser,
+  flaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserFlagged } from '~/user/events';
+
+import { createReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('createReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: ca4a760f-4342-4a99-9f3c-6c17cd205ca6
+  test('it should flag user with userId', async () => {
+    const expected = true;
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const received = await createReport('user', flaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: e8d0f02c-3558-488f-bdae-e70835d8cefb
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(createReport('user', flaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = flaggedUser;
+
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserFlagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await createReport('user', flaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  test.todo('it should fire event for flagging message');
+  test.todo('it should fire event for flagging post');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/flag`],
+    ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
+  ];
+
+  test.each(tests)(
+    'it should call the appropriate api for %s',
+    async (referenceType, referenceId, expected) => {
+      const apimock = jest.fn();
+
+      client.http.post = apimock.mockResolvedValue({ data: {} });
+
+      await createReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = flaggedUser;
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    await createReport('user', flaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', flaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/report/api/tests/deleteReport.test.ts

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser as unflaggedUser,
+  flaggedUserQueryResponse as unflaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserUnflagged } from '~/user/events';
+
+import { deleteReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('deleteReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: fddf1d63-98e2-4296-ab3a-4e2b55044f89
+  test('it should unflag user with userId', async () => {
+    const expected = true;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const received = await deleteReport('user', unflaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: a95a0784-56ce-4b17-ac1b-0f1c50a361ef
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(deleteReport('user', unflaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = unflaggedUser;
+
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUnflagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await deleteReport('user', unflaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  test.todo('it should fire event for unflagging message');
+  test.todo('it should fire event for unflagging delete');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/unflag`],
+    ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
+  ];
+
+  test.each(tests)(
+    'it should call the appropriate api for %s',
+    async (referenceType, referenceId, expected) => {
+      const apimock = jest.fn();
+
+      client.http.delete = apimock.mockResolvedValue({ data: {} });
+
+      await deleteReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = unflaggedUser;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    await deleteReport('user', unflaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', unflaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/stream/api/createStream.ts

@@ -2,6 +2,9 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: stream.create
+*/
 /**
  * ```js
  * import { createStream } from '@amityco/ts-sdk'
@@ -34,3 +37,4 @@ export const createStream = async (
     cachedAt,
   };
 };
+/* end_public_function */

package/src/stream/api/deleteStream.ts

@@ -6,6 +6,9 @@ import { getStream } from './getStream';
 
 // import { unwrapPayload } from '~/core/transports'
 
+/* begin_public_function
+  id: stream.delete
+*/
 /**
  * ```js
  * import { deleteStream } from '@amityco/ts-sdk'

package/src/stream/api/getStream.ts

@@ -3,6 +3,9 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: stream.get
+*/
 /**
  * ```js
  * import { getStream } from '@amityco/ts-sdk'
@@ -37,6 +40,7 @@ export const getStream = async (
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/stream/api/queryStreams.ts

@@ -3,6 +3,9 @@ import { getActiveClient } from '~/client/api';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+/* begin_public_function
+  id: stream.query
+*/
 /**
  * ```js
  * import { queryStreams } from '@amityco/ts-sdk'
@@ -55,6 +58,7 @@ export const queryStreams = async (query?: {
 
   return { data: videoStreamings, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/stream/api/tests/createStream.test.ts

@@ -0,0 +1,22 @@
+import { getActiveClient } from '~/client/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+import { createStream } from '../createStream';
+
+const bundle: Parameters<typeof createStream>[0] = {
+  title: 'my stream',
+  thumbnailFileId: streamResponse.data.videoStreamings[0].thumbnailFileId,
+};
+
+describe('createStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  it('creates a stream and returns the new stream', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(streamResponse);
+
+    const created = await createStream(bundle);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(`/api/v3/video-streaming`, bundle);
+    expect(created.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});