@amityco/ts-sdk 6.2.0 → 6.2.1-0cf9bee.0

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

@@ -1,14 +1,5 @@
-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 '~/userRepository/events';
+import { disableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient } from '~/utils/tests';
 
 import { deleteReport } from '..';
 import REFERENCE_TYPES from '../../constants/referenceTypes';
@@ -18,48 +9,10 @@ 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`],
   ];
@@ -78,17 +31,4 @@ describe('deleteReport', () => {
       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/subChannelRepository/api/startReadingAPI.ts

@@ -1,5 +1,11 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api';
+import {
+  channelMarkerReducer,
+  feedMarkerReducer,
+  subChannelMarkerReducer,
+  userMarkerReducer,
+} from '~/marker/utils/markerDispatcher';
 
 /**
  * ```js
@@ -26,8 +32,15 @@ export const startReadingAPI = async (
     `/api/v1/markers/message-feeds/${messageFeedId}/start-reading`,
   );
 
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(payload as Amity.StartReadingPayload, { cachedAt });
 
+  feedMarkerReducer('local.feedMarker.fetched', feedMarkers);
+  channelMarkerReducer('local.channelMarker.fetched', userEntityMarkers);
+  subChannelMarkerReducer('local.subChannelMarker.fetched', userFeedMarkers);
+  userMarkerReducer('local.userMarker.fetched', userMarkers);
+
   return true;
 };

package/src/subChannelRepository/api/stopReadingAPI.ts

@@ -1,5 +1,11 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getActiveClient } from '~/client/api';
+import {
+  channelMarkerReducer,
+  feedMarkerReducer,
+  subChannelMarkerReducer,
+  userMarkerReducer,
+} from '~/marker/utils/markerDispatcher';
 
 /**
  * ```js
@@ -26,8 +32,15 @@ export const stopReadingAPI = async (
     `/api/v1/markers/message-feeds/${messageFeedId}/stop-reading`,
   );
 
+  const { userEntityMarkers, userFeedMarkers, feedMarkers, userMarkers } = payload;
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(payload as Amity.StopReadingPayload, { cachedAt });
 
+  feedMarkerReducer('local.feedMarker.fetched', feedMarkers);
+  channelMarkerReducer('local.channelMarker.fetched', userEntityMarkers);
+  subChannelMarkerReducer('local.subChannelMarker.fetched', userFeedMarkers);
+  userMarkerReducer('local.userMarker.fetched', userMarkers);
+
   return true;
 };

package/src/userRepository/api/flagUser.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/* begin_public_function
+  id: user.flag
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const flagged = await UserRepository.flagUser('userId')
+ * ```
+ *
+ * @param userId The ID of the user to add a be flagged
+ * @returns the created report result
+ *
+ * @category User API
+ * @async
+ * */
+export const flagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('user/flagUser', userId);
+
+  const { data: payload } = await client.http.post<Amity.UserPayload>(
+    `api/v4/me/flags/${encodeURIComponent(userId)}`,
+  );
+
+  if (client.cache) {
+    ingestInCache(payload);
+  }
+
+  fireEvent('user.flagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/userRepository/api/index.ts

@@ -1,2 +1,6 @@
 export { getUserByIds } from './getUserByIds';
 export { updateUser } from './updateUser';
+
+export { flagUser } from './flagUser';
+export { unflagUser } from './unflagUser';
+export { isUserFlaggedByMe } from './isUserFlaggedByMe';

package/src/userRepository/api/isUserFlaggedByMe.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { synchronousWSCall } from '~/core/transports';
+
+/* begin_public_function
+  id: user.check_flag_by_me
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const isFlagged = await UserRepository.isUserFlaggedByMe('post', postId)
+ * ```
+ *
+ * @param userId The ID of the thing to check a report to.
+ * @returns `true` if the report is created by me, `false` if doesn't.
+ *
+ * @category Report API
+ * @async
+ * */
+export const isUserFlaggedByMe = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('user/isUserFlaggedByMe', userId);
+
+  const { result, isFlagByMe } =
+    (await synchronousWSCall<{
+      result?: boolean;
+      isFlagByMe?: boolean;
+    }>(client, 'user.isFlagByMe', {
+      userId,
+    })) ?? {};
+
+  return result ?? isFlagByMe ?? false;
+};
+/* end_public_function */

package/src/userRepository/{relationship/block/api → api}/queryBlockedUsers.ts

@@ -6,8 +6,8 @@ import { toPageRaw } from '~/core/query';
 
 /**
  * ```js
- * import { queryBlockedUsers } from '@amityco/ts-sdk'
- * const { data: users, prevPage, nextPage, total } = await queryBlockedUsers({ page: Amity.PageRaw, limit: number })
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const { data: users, prevPage, nextPage, total } = await UserRepository.queryBlockedUsers({ page: Amity.PageRaw, limit: number })
  * ```
  *
  * @param query The query parameters
@@ -16,6 +16,7 @@ import { toPageRaw } from '~/core/query';
  * @category Block API
  * @async
  */
+
 export const queryBlockedUsers = async (
   query?: Amity.QueryBlockedUser,
 ): Promise<

package/src/userRepository/api/tests/flagUser.test.ts

@@ -0,0 +1,81 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser,
+  flaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { fireEvent } from '~/core/events';
+
+import { flagUser } from '..';
+
+jest.mock('~/core/events', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/events'),
+  fireEvent: jest.fn(),
+}));
+
+describe('flagUser', () => {
+  beforeEach(disableCache);
+  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 flagUser(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(flagUser(flaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should call fire event method', async () => {
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const recieved = await flagUser(flaggedUser.userId);
+    const [recievedMqttString] = (fireEvent as jest.Mock).mock.lastCall;
+
+    expect(recieved).toBe(true);
+    expect(recievedMqttString).toBe('user.flagged');
+  });
+
+  test('it should call the appropriate api', async () => {
+    const apimock = jest.fn();
+    const expected = `api/v4/me/flags/${encodeURIComponent('userId')}`;
+
+    client.http.post = apimock.mockResolvedValue({ data: {} });
+
+    await flagUser('userId');
+
+    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 flagUser(flaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', flaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/userRepository/{relationship/block/api → api}/tests/queryBlockedUsers.test.ts

@@ -1,5 +1,5 @@
 import { client, user12, user13 } from '~/utils/tests';
-import { queryBlockedUsers } from '~/userRepository/relationship/block/api/queryBlockedUsers';
+import { queryBlockedUsers } from '~/userRepository/api/queryBlockedUsers';
 import { disableCache, enableCache } from '~/cache/api';
 import { generateBlockedUsers } from '~/utils/tests/dummy/block';
 

package/src/userRepository/api/tests/unflagUser.test.ts

@@ -0,0 +1,80 @@
+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 { fireEvent } from '~/core/events';
+
+import { unflagUser } from '..';
+
+jest.mock('~/core/events', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/events'),
+  fireEvent: jest.fn(),
+}));
+
+describe('unflagUser', () => {
+  beforeEach(disableCache);
+  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 unflagUser(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(unflagUser(unflaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const recieved = await unflagUser(unflaggedUser.userId);
+    const [recievedMqttString] = (fireEvent as jest.Mock).mock.lastCall;
+
+    expect(recieved).toBe(true);
+    expect(recievedMqttString).toBe('user.unflagged');
+  });
+
+  test('it should call the appropriate api', async () => {
+    const apimock = jest.fn();
+    const expected = `/api/v4/me/flags/${encodeURIComponent('userId')}`;
+
+    client.http.delete = apimock.mockResolvedValue({ data: {} });
+
+    await unflagUser('userId');
+    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 unflagUser(unflaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', unflaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/userRepository/api/unflagUser.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/* begin_public_function
+  id: user.unflag
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const unflagged = await UserRepository.unflagUser('post', postId)
+ * ```
+ *
+ * @param userId The ID of the user to unflag
+ * @returns the deleted report result
+ *
+ * @category User API
+ * @async
+ * */
+export const unflagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('user/unflag', userId);
+
+  const { data: payload } = await client.http.delete<Amity.UserPayload>(
+    `/api/v4/me/flags/${encodeURIComponent(userId)}`,
+  );
+
+  if (client.cache) {
+    ingestInCache(payload);
+  }
+
+  fireEvent('user.unflagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/userRepository/observers/getBlockedUsers.ts

@@ -0,0 +1,104 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { createQuery, queryOptions, runQuery, toToken } from '~/core/query';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { getResolver } from '~/core/model';
+import { queryBlockedUsers } from '../api/queryBlockedUsers';
+
+export const getBlockedUsers = (
+  params: Amity.BlockedUsersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, token } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = ['blockedUsers', 'collection', {}];
+
+  const responder = (data: Amity.BlockedUserLiveCollectionCache) => {
+    const users: Amity.User[] =
+      data.data
+        .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      data: users,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  /*
+   * const realtimeRouter = () => {
+   * @TODO: At the time of creating this method category does not have any
+   * observers
+   *};
+   */
+
+  const onFetch = (initial = false) => {
+    const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(cacheKey)?.data;
+
+    const users = collection?.data ?? [];
+
+    if (!initial && users.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryBlockedUsers, {
+      limit,
+      token: toToken(!initial ? collection?.params.page : undefined, 'afterbeforeraw'),
+    });
+
+    runQuery(
+      query,
+      // @ts-ignore
+      ({ data: result, loading, error, nextPage: page, total }) => {
+        const data = {
+          loading,
+          error,
+          params: { page, total },
+          data: users,
+        };
+
+        if (result) {
+          data.data = [...new Set([...users, ...result.map(getResolver('user'))])];
+        }
+
+        pushToCache(cacheKey, data);
+        responder(data);
+      },
+      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
+    );
+  };
+
+  disposers.push(() => {
+    // @TODO -> update once observers added
+  });
+
+  onFetch(true);
+
+  return () => {
+    log(`getCategories(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+    dropFromCache(cacheKey);
+  };
+};

package/src/userRepository/observers/getUsers.ts

@@ -114,16 +114,16 @@ export const getUsers = (
     responder(collection);
   };
 
-  const onFetch = () => {
+  const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.UserLiveCollectionCache>(cacheKey)?.data;
 
     const users = collection?.data ?? [];
 
-    if (users.length > 0 && !collection?.params.page) return;
+    if (!initial && users.length > 0 && !collection?.params.page) return;
 
     const query = createQuery(queryUsers, {
       ...queryParams,
-      page: collection?.params.page ?? { limit },
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
     });
 
     runQuery(
@@ -156,7 +156,7 @@ export const getUsers = (
     onUserFlagCleared(realtimeRouter('onFlagCleared')),
   );
 
-  onFetch();
+  onFetch(true);
 
   return () => {
     log(`liveUsers(tmpid: ${timestamp}) > dispose`);

package/src/userRepository/observers/index.ts

@@ -1,3 +1,4 @@
 export { getUser } from './getUser';
 export { getUsers } from './getUsers';
 export { observeUser } from './observeUser';
+export { getBlockedUsers } from './getBlockedUsers';

package/src/userRepository/observers/tests/getUsers.test.ts

@@ -65,17 +65,11 @@ describe('getUsers', () => {
     getUsers(params, callback);
     await pause();
 
-    expect(callback).toHaveBeenCalledTimes(2);
+    // The second `getUsers` call fetches data from the cache,
+    // so there is no loading state and the callback only fires once.
+    expect(callback).toHaveBeenCalledTimes(1);
     expect(callback).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining(
-        getSnapshot({
-          data: payload.users,
-        }),
-      ),
-    );
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
       expect.objectContaining(
         getSnapshot({
           data: payload.users,