@amityco/ts-sdk-react-native 6.7.1-80c1951.0

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

@@ -0,0 +1,124 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { client, userQueryResponse } from '~/utils/tests';
+
+import { queryUsers } from '../queryUsers';
+
+describe('queryUsers', () => {
+  test('it should return users', async () => {
+    const { users: expected } = userQueryResponse.data;
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    const { data } = await queryUsers();
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryUsers()).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    const { data: expected } = await queryUsers();
+    const { data: received } = queryUsers.locally()!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('queryUsers.locally', () => {
+  const cacheKey = [
+    'user',
+    'query',
+    { options: { limit: 10, after: undefined } } as Amity.Serializable,
+  ];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { data } = userQueryResponse;
+    const { users: expected, paging } = data;
+
+    ingestInCache(data as Amity.UserPayload);
+
+    pushToCache(cacheKey, { users: expected.map(getResolver('user')), paging });
+
+    const { data: received } = queryUsers.locally()!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { data } = userQueryResponse;
+    const { users, paging } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      users: [data.users[0]],
+    } as Amity.UserPayload);
+
+    pushToCache(cacheKey, {
+      users: users.map(getResolver('user')),
+      paging,
+    });
+
+    const received = queryUsers.locally()!;
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  // added because of comment above cache key in queryUsers
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = userQueryResponse;
+    const { users: expected, paging } = data;
+
+    ingestInCache(data as Amity.UserPayload);
+
+    pushToCache(cacheKey, { users: expected.map(getResolver('user')), paging });
+
+    const { data: received } = queryUsers.locally()!;
+    const received2 = queryUsers.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const received = queryUsers.locally();
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryUsers.locally()).toBeUndefined();
+  });
+});

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/tests/updateUser.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+
+import { client, userUpdateResponse } from '~/utils/tests';
+
+import { updateUser } from '../updateUser';
+import { onUserUpdated } from '../../events/onUserUpdated';
+
+describe('updateUser', () => {
+  const displayName = 'updated-display-name';
+  const userId = 'test-user';
+  const avatarCustomUrl = 'updated-avatarUrl';
+
+  // integration_test_id: a1a8260f-3314-41ba-9f5f-3a96dd52453d
+  test('it should return updated user on success', async () => {
+    const { users: expected } = userUpdateResponse.data;
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+
+    const { data: received } = await updateUser(userId, { displayName, avatarCustomUrl });
+
+    expect(received).toStrictEqual(expected[0]);
+  });
+
+  // integration_test_id: 67cb7ad8-28a9-4950-a86c-35497bb5212c
+  test('it should return 400301 when updating another user', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('400301'));
+
+    await expect(
+      updateUser('different-user', { displayName: 'updated-display-name' }),
+    ).rejects.toThrow('400301');
+  });
+
+  test('it should update cache with updated user', async () => {
+    enableCache();
+
+    const expected = userUpdateResponse.data.users[0];
+    pushToCache(['user', 'get', userId], { ...expected, displayName: 'old-displayName' });
+
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+    await updateUser(userId, { displayName, avatarCustomUrl });
+
+    const received = pullFromCache(['user', 'get', userId])?.data;
+
+    expect(received).toStrictEqual(expected);
+    disableCache();
+  });
+
+  test('it should fire event for updated user', async () => {
+    let dispose;
+    const { users: expected } = userUpdateResponse.data;
+    client.http.put = jest.fn().mockResolvedValue(userUpdateResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUpdated(resolve);
+    }).finally(dispose);
+
+    await updateUser(userId, { displayName, avatarCustomUrl });
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected[0]));
+  });
+});

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-react-native'
+ * 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/api/updateUser.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: client.update_user
+*/
+/**
+ * ```js
+ * import { updateUser } from '@amityco/ts-sdk-react-native'
+ * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.User}
+ *
+ * @param userId The ID of the {@link Amity.User} to update
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+export const updateUser = async (
+  userId: Amity.User['userId'],
+  patch: Patch<
+    Amity.User,
+    'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
+  >,
+): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/updateUser', userId, patch);
+
+  // API-FIX: Endpoint is malformed, userId should be a url param.
+  /*
+    const { data } = await client.http.put<Amity.Response<UserPayload>>(
+      `/api/v3/users/${userId}`, patch,
+    )
+  */
+
+  const { data } = await client.http.put<Amity.UserPayload>(`/api/v3/users/`, {
+    userId,
+    ...patch,
+    createNewUserWhenNotFound: false,
+  });
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { users } = data;
+
+  fireEvent('user.updated', data);
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/userRepository/events/index.ts

@@ -0,0 +1,6 @@
+export * from './onUserUpdated';
+export * from './onUserDeleted';
+
+export * from './onUserFlagged';
+export * from './onUserUnflagged';
+export * from './onUserFlagCleared';

package/src/userRepository/events/onUserDeleted.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserDeleted(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserDeleted = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.deleted', callback);

package/src/userRepository/events/onUserFetched.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFetched } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFetched(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFetched = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.fetched', callback);

package/src/userRepository/events/onUserFlagCleared.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.User}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFlagCleared = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.flagCleared', callback);

package/src/userRepository/events/onUserFlagged.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFlagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFlagged = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.flagged', callback);

package/src/userRepository/events/onUserUnflagged.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUnflagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserUnflagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.User}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserUnflagged = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.unflagged', callback);

package/src/userRepository/events/onUserUpdated.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUpdated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.User} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserUpdated = (callback: Amity.Listener<Amity.User>) =>
+  createUserEventSubscriber('user.updated', callback);

package/src/userRepository/events/utils.ts

@@ -0,0 +1,21 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+export const createUserEventSubscriber = (
+  event: keyof Amity.MqttUserEvents,
+  callback: Amity.Listener<Amity.User>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.UserPayload) => {
+    if (client.cache) {
+      ingestInCache(payload);
+    }
+
+    callback(payload.users[0]);
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/userRepository/index.ts

@@ -0,0 +1,5 @@
+export * as Relationship from './relationship';
+
+export * from './api';
+export * from './events';
+export * from './observers';

package/src/userRepository/observers/getBlockedUsers.ts

@@ -0,0 +1,123 @@
+/* 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';
+
+/* begin_public_function
+  id: user.get_blocked_users
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk-react-native'
+ * const unblockedUser = await UserRepository.blockUser('userId')
+ * ```
+ *
+ * Blocks a {@link Amity.User}
+ *
+ * @param params The params to get blocked {@link Amity.User}s
+ * @param callback to recieve updates on unblocked {@link Amity.User}s
+ * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
+ *
+ * @category Post API
+ * @async
+ */
+export const getBlockedUsers = (
+  params: Amity.BlockedUsersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit } = 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 api blocked user do 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);
+  };
+};
+/* end_public_function */

package/src/userRepository/observers/getUser.ts

@@ -0,0 +1,47 @@
+import { liveObject } from '~/utils/liveObject';
+import {
+  onUserDeleted,
+  onUserUpdated,
+  onUserFlagCleared,
+  onUserFlagged,
+  onUserUnflagged,
+} from '../events';
+import { onUserFetched } from '../events/onUserFetched';
+import { getUser as _getUser } from '../api/getUser';
+
+/* begin_public_function
+  id: user.get
+*/
+/**
+ * ```js
+ * import { liveUser } from '@amityco/ts-sdk-react-native';
+ *
+ * let user;
+ *
+ * const unsubscribe = liveUser(userId, response => {
+ *   user = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ *
+ * @param userId the ID of the user to observe
+ * @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 user
+ *
+ * @category Message Live Object
+ */
+export const getUser = (
+  userId: Amity.User['userId'],
+  callback: Amity.LiveObjectCallback<Amity.User>,
+): Amity.Unsubscriber => {
+  return liveObject(userId, callback, 'userId', _getUser, [
+    onUserFetched,
+    onUserUpdated,
+    onUserDeleted,
+    onUserFlagged,
+    onUserUnflagged,
+    onUserFlagCleared,
+  ]);
+};
+/* end_public_function */