@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/userRepository/api/queryBlockedUsers.ts

@@ -1,117 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { getResolver } from '~/core/model';
-import { toPageRaw } from '~/core/query';
-import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
-
-/**
- * ```js
- * 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
- * @returns A page of {@link Amity.User} objects
- *
- * @category Block API
- * @async
- */
-
-export const queryBlockedUsers = async (
-  query?: Amity.QueryBlockedUser,
-): Promise<
-  Amity.Cached<Amity.Paged<Amity.User, Amity.PageRaw>> & {
-    total: number;
-  }
-> => {
-  const client = getActiveClient();
-
-  let params = {};
-
-  if (query) {
-    const { token, limit } = query;
-    params = {
-      limit,
-      token,
-    };
-  }
-
-  client.log('user/queryBlockedUsers');
-  const { data } = await client.http.get<Amity.BlockedUserPayload>('/api/v4/me/user-blocks', {
-    params,
-  });
-
-  const payload = prepareUserPayload(data);
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) {
-    ingestInCache(payload, { cachedAt });
-
-    const cacheKey = ['blockedUsers', 'query', params as Amity.Serializable];
-    pushToCache(cacheKey, { users: payload.users.map(getResolver('user')), paging: data.paging });
-  }
-
-  const { next, previous, total } = data.paging;
-  const nextPage = toPageRaw(next);
-  const prevPage = toPageRaw(previous);
-
-  return { data: payload.users, prevPage, nextPage, total, cachedAt };
-};
-
-/**
- * ```js
- * import { queryBlockedUsers } from '@amityco/ts-sdk'
- * const { data: users } = queryBlockedUsers.locally({ page: 'page_token' })
- * ```
- *
- * Queries a paginable list of {@link Amity.User} objects from cache
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
- *
- * @category Block API
- */
-queryBlockedUsers.locally = (
-  query: Parameters<typeof queryBlockedUsers>[0] = {},
-):
-  | (Amity.Cached<Amity.Paged<Amity.InternalUser, Amity.PageRaw>> & {
-      total: number;
-    })
-  | undefined => {
-  const client = getActiveClient();
-  client.log('user/queryBlockedUsers.locally');
-
-  if (!client.cache) return;
-
-  let params = {};
-  if (query) {
-    const { token, limit } = query;
-    params = {
-      token,
-      limit,
-    };
-  }
-
-  const cacheKey = ['blockedUsers', 'query', params as Amity.Serializable];
-
-  const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.BlockedUserPaged>(
-      cacheKey,
-    ) ?? {};
-
-  const users: Amity.InternalUser[] =
-    data?.users
-      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
-      .filter(Boolean)
-      .map(({ data }) => data) ?? [];
-
-  const nextPage = toPageRaw(data?.paging.next);
-  const prevPage = toPageRaw(data?.paging.previous);
-
-  return users.length > 0 && users.length === data?.users?.length
-    ? { data: users, nextPage, prevPage, total: data?.paging.total, cachedAt }
-    : undefined;
-};

package/src/userRepository/api/queryUsers.ts

@@ -1,59 +0,0 @@
-import { LinkedObject } from '~/utils/linkedObject';
-import { queryUsers as queryUsersInternal } from '../internalApi/queryUsers';
-
-/**
- * ```js
- * import { queryUsers } from '@amityco/ts-sdk'
- * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.User} objects
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
- *
- * @category User API
- * @async
- */
-export const queryUsers = async (
-  query: Amity.QueryUsers = {},
-): Promise<Amity.Cached<Amity.PageToken<Amity.User>>> => {
-  const { cachedAt, data, paging } = await queryUsersInternal(query);
-
-  return {
-    data: data.map(user => LinkedObject.user(user)),
-    cachedAt,
-    paging,
-  };
-};
-
-/**
- * ```js
- * import { queryUsers } from '@amityco/ts-sdk'
- * const { data: users } = queryUsers.locally({ keyword: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.User} objects from cache
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
- *
- * @category User API
- */
-queryUsers.locally = (
-  query: Parameters<typeof queryUsers>[0] = {},
-): Amity.Cached<Amity.PageToken<Amity.User>> | undefined => {
-  const cache = queryUsersInternal.locally(query);
-
-  if (!cache) return;
-
-  const { cachedAt, data, paging } = cache;
-
-  return {
-    data: data.map(LinkedObject.user),
-    cachedAt,
-    paging,
-  };
-};

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

@@ -1,81 +0,0 @@
-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/api/tests/getUser.test.ts

@@ -1,126 +0,0 @@
-import { ASCApiError } from '~/core/errors';
-import { disableCache, enableCache, pushToCache } from '~/cache/api';
-import { client, user11 } from '~/utils/tests';
-
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { isInTombstone } from '~/cache/api/isInTombstone';
-
-import { getUser } from '../getUser';
-
-const user = user11;
-const getResolvedUserValue = () => ({
-  data: {
-    users: [user],
-    files: [],
-  },
-});
-
-describe('getUser', () => {
-  // integration_test_id: c9d28b37-c761-4df5-ac86-060a506f3007
-  test('should return user data', async () => {
-    client.http.get = jest.fn().mockResolvedValue(getResolvedUserValue());
-
-    const { data } = await getUser(user.userId);
-
-    expect(data).toStrictEqual(user);
-  });
-
-  test('it should update cache after fetch from server', async () => {
-    enableCache();
-    client.http.get = jest.fn().mockResolvedValue(getResolvedUserValue());
-    await getUser(user.userId);
-
-    expect(getUser.locally(user.userId)).toBeDefined();
-
-    disableCache();
-  });
-
-  // integration_test_id: b5204e28-7e11-44ff-b391-48181f1822ba
-  test('should return an error', async () => {
-    const expected = new ASCApiError(
-      'User not found',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    client.http.get = jest.fn().mockRejectedValue({
-      data: expected,
-    });
-
-    try {
-      await getUser(user.userId);
-    } catch ({ data = null }) {
-      expect(data).toEqual(expected);
-    }
-  });
-
-  test('should return an error if user in cache but api throws not found', async () => {
-    enableCache();
-    pushToCache(['user', 'get', user.userId], user, { cachedAt: Date.now() });
-
-    client.http.get = jest
-
-      .fn()
-      .mockRejectedValueOnce(
-        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
-      );
-
-    await expect(getUser(user.userId)).rejects.toThrow();
-
-    expect(getUser.locally(user.userId)).toBeUndefined();
-    disableCache();
-  });
-});
-
-describe('getUser locally', () => {
-  test('should return data from cache', () => {
-    enableCache();
-
-    const cachedAt = Date.now();
-
-    pushToCache(['user', 'get', user.userId], user, { cachedAt });
-
-    const data = getUser.locally(user.userId);
-
-    expect(data).toBeDefined();
-    expect(data?.data).toEqual(user);
-    expect(data?.cachedAt).toEqual(cachedAt);
-
-    disableCache();
-  });
-
-  test('should return undefined if user not in cache', () => {
-    expect(getUser.locally('non-existent-user')).toBeUndefined();
-  });
-
-  test('should return undefined if cache not enabled', () => {
-    expect(getUser.locally(user.userId)).toBeUndefined();
-  });
-});
-
-describe('getUser tombostone', () => {
-  test('it should add user to tombostone if 404', async () => {
-    enableCache();
-    client.http.get = jest
-      .fn()
-      .mockRejectedValueOnce(
-        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
-      );
-
-    await expect(getUser(user.userId)).rejects.toThrow();
-    expect(() => {
-      isInTombstone('user', user.userId);
-    }).toThrow();
-
-    disableCache();
-  });
-
-  test('it should throw error if user not found in tombostone', async () => {
-    enableCache();
-
-    pushToTombstone('user', user.userId);
-    await expect(getUser(user.userId)).rejects.toThrow();
-
-    disableCache();
-  });
-});

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

@@ -1,28 +0,0 @@
-import { client, user12, user13 } from '~/utils/tests';
-import { queryBlockedUsers } from '~/userRepository/api/queryBlockedUsers';
-import { disableCache, enableCache } from '~/cache/api';
-import { generateBlockedUsers } from '~/utils/tests/dummy/block';
-
-const BlockedUsersPayload = generateBlockedUsers(user12, user13);
-
-const BlockedUserEmptyList = generateBlockedUsers();
-
-describe('queryBlockedUsers', () => {
-  // integration_test_id: 5ac964db-43c9-459f-8bcf-2fd034a62907
-  it('should return a list of blocked users', async () => {
-    enableCache();
-    client.http.get = jest.fn().mockResolvedValue(BlockedUsersPayload);
-    const { data } = await queryBlockedUsers();
-    expect(data).toEqual(BlockedUsersPayload.data.users);
-    disableCache();
-  });
-
-  // integration_test_id: f9133599-0aa5-438d-bd69-7231ca64232a
-  it('should return an empty list of blocked users', async () => {
-    enableCache();
-    client.http.get = jest.fn().mockResolvedValue(BlockedUserEmptyList);
-    const { data } = await queryBlockedUsers();
-    expect(data).toEqual(BlockedUserEmptyList.data.users);
-    disableCache();
-  });
-});

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

@@ -1,124 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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]));
-  });
-});