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

package/src/categoryRepository/observers/tests/getCategories.test.ts

@@ -1,139 +0,0 @@
-import { disableCache, enableCache } from '~/cache/api';
-import {
-  client,
-  connectClient,
-  disconnectClient,
-  pause,
-  categoryQueryResponse,
-  categoryQueryResponsePage2,
-  category11,
-  category12,
-} from '~/utils/tests';
-import { sortByName } from '~/core/query';
-
-import { getCategories } from '../getCategories';
-import { LinkedObject } from '~/utils/linkedObject';
-
-const getSnapshot = (params?: Record<string, any>) => {
-  return {
-    data: [] as Amity.Category[],
-    loading: true,
-    error: undefined as any,
-    ...params,
-  };
-};
-
-const params = { includeDeleted: true };
-
-describe('getCategories', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  beforeEach(enableCache);
-
-  afterEach(disableCache);
-
-  const payload = categoryQueryResponse.data;
-  const payloadPage2 = categoryQueryResponsePage2.data;
-
-  test('it should return category collection', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
-
-    getCategories(params, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining(
-        getSnapshot({
-          data: payload.categories.map(category => LinkedObject.category(category)),
-          loading: false,
-        }),
-      ),
-    );
-  });
-
-  test('it should return data from cache', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
-
-    getCategories(params, () => undefined);
-    await pause();
-
-    getCategories(params, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          data: payload.categories,
-          loading: false,
-        }),
-      ),
-    );
-  });
-
-  const filters: [string, Amity.CategoryLiveCollection, Amity.Category[]][] = [
-    ['not deleted', { includeDeleted: false }, [category11, category12]],
-  ];
-
-  test.each(filters)('it should filter by %s categories', async (filter, params, expected) => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
-
-    getCategories(params, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: expected,
-        }),
-      ),
-    );
-  });
-
-  test('it should return method to fetch next page', async () => {
-    const callback = jest.fn();
-    client.http.get = jest
-      .fn()
-      .mockResolvedValue(categoryQueryResponse)
-      .mockResolvedValueOnce(categoryQueryResponsePage2);
-
-    getCategories(params, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback.mock.lastCall).toHaveLength(1);
-
-    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
-
-    expect(hasNextPage).toBe(true);
-    expect(onNextPage).toBeTruthy();
-
-    onNextPage();
-    await pause();
-
-    // 4 -> because 1 local & server call each per call (2)
-    expect(callback).toHaveBeenCalledTimes(4);
-    expect(callback).toHaveBeenNthCalledWith(
-      4,
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: [...payloadPage2.categories, ...payload.categories].sort(sortByName),
-        }),
-      ),
-    );
-  });
-});

package/src/channelRepository/api/createChannel.ts

@@ -1,63 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareChannelPayload } from '../utils';
-import { constructChannelObject } from '../utils/constructChannelObject';
-
-/* begin_public_function
-  id: channel.create
-*/
-/**
- * ```js
- * import { createChannel } from '@amityco/ts-sdk'
- * const created = await createChannel({ displayName: 'foobar' })
- * ```
- *
- * Creates an {@link Amity.Channel}
- *
- * @param bundle The data necessary to create a new {@link Amity.Channel}
- * @returns The newly created {@link Amity.Channel}
- *
- * @category Channel API
- * @async
- */
-export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: {
-    type: T;
-    userIds?: Amity.InternalUser['userId'][];
-    // For live channel linked with a livestream post
-    videoStreamId?: string;
-    postId?: string;
-  } & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata' | 'isPublic'>,
-): Promise<Amity.Cached<Amity.Channel<T>>> => {
-  const client = getActiveClient();
-  client.log('user/createChannel', bundle);
-
-  let payload;
-
-  if (bundle?.type === 'conversation') {
-    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels/conversation', {
-      ...bundle,
-      isDistinct: true,
-    });
-  } else {
-    const { isPublic, ...restParams } = bundle;
-
-    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', {
-      ...restParams,
-      isPublic: bundle?.type === 'community' ? isPublic : undefined,
-    });
-  }
-  const data = await prepareChannelPayload(payload.data);
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { channels } = data;
-  return {
-    data: constructChannelObject(channels[0]),
-    cachedAt,
-  };
-};
-/* end_public_function */

package/src/channelRepository/api/deleteChannel.ts

@@ -1,34 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { getChannel } from '../internalApi/getChannel';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
-
-/**
- * ```js
- * import { deleteChannel } from '@amityco/ts-sdk'
- * const success = await deleteChannel('foobar')
- * ```
- *
- * Deletes a {@link Amity.Channel}
- *
- * @param channelId The {@link Amity.Channel} ID to delete
- * @return A success boolean if the {@link Amity.Channel} was deleted
- *
- * @category Channel API
- * @async
- */
-export const deleteChannel = async (
-  channelId: Amity.Channel['channelId'],
-): Promise<Amity.InternalChannel> => {
-  const client = getActiveClient();
-  client.log('channel/deleteChannel', channelId);
-
-  await client.http.delete<{ success: boolean }>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}`,
-  );
-
-  const deleted = await getChannel(channelId);
-  // no need for event, fired by server
-
-  return constructChannelDynamicValue(deleted.data);
-};

package/src/channelRepository/api/getChannelByIds.ts

@@ -1,107 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { queryCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { checkIfShouldGoesToTombstone } from '~/cache/utils';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { prepareChannelPayload } from '../utils';
-import { fireEvent } from '~/core/events';
-import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
-
-import { constructChannelObject } from '../utils/constructChannelObject';
-
-/**
- * ```js
- * import { getChannelByIds } from '@amityco/ts-sdk'
- * const channels = await getChannelByIds(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.Channel} objects
- *
- * @param channelIds the IDs of the {@link Amity.Channel} to fetch
- * @returns the associated collection of {@link Amity.Channel} objects
- *
- * @category Channel API
- * @async
- */
-export const getChannelByIds = async (
-  channelIds: Amity.Channel['channelPublicId'][],
-): Promise<Amity.Cached<Amity.Channel[]>> => {
-  const client = getActiveClient();
-  client.log('channel/getChannelByIds', channelIds);
-
-  const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
-
-  let payload: Amity.ChannelPayload;
-
-  try {
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const response = await client.http.get<Amity.ChannelPayload>(`/api/v3/channels/list`, {
-      params: { channelIds: encodedChannelIds },
-    });
-
-    payload = response.data;
-  } catch (error) {
-    channelIds.forEach(channelId => {
-      if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
-        // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
-        pushToTombstone('channel', channelId);
-      }
-    });
-
-    throw error;
-  }
-
-  const data = await prepareChannelPayload(payload);
-
-  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-    await prepareUnreadCountInfo(payload);
-  }
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  fireEvent('local.channel.fetched', data.channels);
-
-  return {
-    data: data.channels.map(channel => constructChannelObject(channel)),
-    cachedAt,
-  };
-};
-
-/**
- * ```js
- * import { getChannelByIds } from '@amityco/ts-sdk'
- * const channels = getChannelByIds.locally(['foo', 'bar']) ?? []
- * ```
- *
- * Fetches a collection of {@link Amity.Channel} objects from cache
- *
- * @param channelIds the IDs of the {@link Amity.Channel} to fetch
- * @returns the associated collection of {@link Amity.Channel} objects
- *
- * @category Channel API
- */
-getChannelByIds.locally = (
-  channelIds: Amity.Channel['channelPublicId'][],
-): Amity.Cached<Amity.Channel[]> | undefined => {
-  const client = getActiveClient();
-  client.log('channel/getChannelByIds.locally', channelIds);
-
-  if (!client.cache) return;
-
-  const cached = queryCache<Amity.StaticInternalChannel>(['channel', 'get'])?.filter(({ data }) => {
-    return channelIds.includes(data.channelPublicId);
-  });
-
-  if (!cached || cached?.length < channelIds.length) return;
-
-  const channels = cached.map(({ data }) => data);
-  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
-
-  return {
-    data: channels.map(channel => constructChannelObject(channel)),
-    cachedAt: oldest.cachedAt,
-  };
-};

package/src/channelRepository/api/index.ts

@@ -1,11 +0,0 @@
-export * from './getChannelByIds';
-
-export * from './createChannel';
-export * from './updateChannel';
-export * from './deleteChannel';
-
-export * from './joinChannel';
-export * from './leaveChannel';
-
-export * from './muteChannel';
-export * from './unmuteChannel';

package/src/channelRepository/api/joinChannel.ts

@@ -1,42 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareChannelPayload } from '../utils';
-
-/* begin_public_function
-  id: channel.join
-*/
-/**
- * ```js
- * import { joinChannel } from '@amityco/ts-sdk'
- * const isJoined = await joinChannel('foobar')
- * ```
- *
- * Joins a {@link Amity.Channel} object
- *
- * @param channelId the {@link Amity.Channel} to join
- * @returns A success boolean if the {@link Amity.Channel} was joined
- *
- * @category Channel API
- * @async
- */
-export const joinChannel = async (channelId: Amity.Channel['channelId']): Promise<boolean> => {
-  const client = getActiveClient();
-  client.log('channel/joinChannel', channelId);
-
-  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}/join`,
-  );
-
-  const data = await prepareChannelPayload(payload);
-
-  if (client.cache) ingestInCache(data);
-
-  const { channelUsers } = data;
-
-  return !!channelUsers.find(
-    channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
-  );
-};
-/* end_public_function */

package/src/channelRepository/api/leaveChannel.ts

@@ -1,42 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareChannelPayload } from '../utils';
-
-/* begin_public_function
-  id: channel.leave
-*/
-/**
- * ```js
- * import { leaveChannel } from '@amityco/ts-sdk'
- * const isLeft = await leaveChannel('foobar')
- * ```
- *
- * Leave a {@link Amity.Channel} object
- *
- * @param channelId the {@link Amity.Channel} to leave
- * @returns A success boolean if the {@link Amity.Channel} was left
- *
- * @category Channel API
- * @async
- */
-export const leaveChannel = async (channelId: Amity.Channel['channelId']): Promise<boolean> => {
-  const client = getActiveClient();
-  client.log('channel/leaveChannel', channelId);
-
-  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}/leave`,
-  );
-
-  const data = await prepareChannelPayload(payload);
-
-  if (client.cache) ingestInCache(data);
-
-  const { channelUsers } = data;
-
-  return !!channelUsers.find(
-    channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
-  );
-};
-/* end_public_function */

package/src/channelRepository/api/markChannelsAsReadBySegment.ts

@@ -1,29 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-/**
- *
- * Mark subChannel as read by readToSegment
- *
- * @param subChannelIds the IDs of the {@link Amity.SubChannel} to update
- * @param readToSegment the segment to mark as read
- * @returns a success boolean if the {@link Amity.SubChannel} was updated
- *
- * @category Channel API
- * @async
- */
-
-export const markChannelsAsReadBySegment = async (
-  readings: {
-    channelId: Amity.Channel['channelId'];
-    readToSegment: number;
-  }[],
-): Promise<boolean> => {
-  const client = getActiveClient();
-
-  try {
-    await client.http.post<Amity.MarkAsReadPayload>('api/v3/channels/seen', { channels: readings });
-    return true;
-  } catch (e) {
-    return false;
-  }
-};

package/src/channelRepository/api/muteChannel.ts

@@ -1,46 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { ASCError } from '~/core/errors';
-
-/* begin_public_function
-  id: channel.mute
-*/
-const MUTE_FOREVER = -1;
-/**
- * ```js
- * import { ChannelRepository } from '@amityco/ts-sdk'
- * const isMuted = await ChannelRepository.muteChannel('channel-id', 100)
- * ```
- *
- * Mutes a {@link Amity.Channel} object
- *
- * @param channelId the {@link Amity.Channel} to mute
- * @param mutePeriod the duration to be muted
- * @returns A success boolean if the {@link Amity.Channel} was muted
- *
- * @category Channel API
- * @async
- */
-export const muteChannel = async (
-  channelId: Amity.Channel['channelId'],
-  mutePeriod = MUTE_FOREVER,
-): Promise<boolean> => {
-  const client = getActiveClient();
-  client.log('channel/muteChannel', channelId);
-
-  if (mutePeriod !== MUTE_FOREVER && mutePeriod < 0)
-    throw new ASCError(
-      `Mute Period can only be positive numbers or ${MUTE_FOREVER}(mute forever)`,
-      Amity.ClientError.INVALID_PARAMETERS,
-      Amity.ErrorLevel.ERROR,
-    );
-
-  const { data } = await client.http.put<{ success: boolean }>(
-    `/api/v2/channel/${encodeURIComponent(channelId)}/mute`,
-    { mutePeriod },
-  );
-
-  const { success } = data;
-
-  return success;
-};
-/* end_public_function */

package/src/channelRepository/api/queryChannels.ts

@@ -1,64 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { getResolver } from '~/core/model';
-
-import { pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareChannelPayload } from '../utils';
-
-/**
- * ```js
- * import { queryChannels } from '@amityco/ts-sdk'
- * const channels = await queryChannels()
- * ```
- *
- * Queries a paginable list of {@link Amity.Channel} objects
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Channel} objects
- *
- * @category Channel API
- * @async
- */
-export const queryChannels = async (
-  query?: Amity.QueryChannels,
-): Promise<Amity.Cached<Amity.PageToken<Amity.InternalChannel>>> => {
-  const client = getActiveClient();
-  client.log('channel/queryChannels', query);
-
-  // safe decapsulation
-  const { page = undefined, limit = 10, displayName, membership, ...params } = query ?? {};
-
-  // API-FIX: parameters should be querystring.
-  // API-FIX: backend doesn't answer Amity.Response
-  // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
-  const { data: queryPayload } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
-    `/api/v3/channels`,
-    {
-      params: {
-        ...params,
-        keyword: displayName,
-        filter: membership,
-        options: page ? { token: page } : { limit },
-      },
-    },
-  );
-
-  const { paging, ...payload } = queryPayload;
-
-  const data = await prepareChannelPayload(payload);
-
-  const { channels } = data;
-
-  const cachedAt = client.cache && Date.now();
-
-  if (client.cache) {
-    ingestInCache(data, { cachedAt });
-
-    const cacheKey = ['channel', 'query', { ...params, options: { limit } } as Amity.Serializable];
-    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
-  }
-
-  return { data: channels, cachedAt, paging };
-};

package/src/channelRepository/api/tests/createChannel.test.ts

@@ -1,100 +0,0 @@
-import { disableCache, enableCache, pullFromCache } from '~/cache/api';
-import {
-  channelPayload,
-  client,
-  connectClient,
-  conversationChannelPayload,
-  convertRawChannelPayload,
-  disconnectClient,
-  liveChannelPayload,
-  rawChannelPayload,
-} from '~/utils/tests';
-
-import { createChannel } from '../createChannel';
-
-const resPayload = { data: rawChannelPayload };
-
-describe('createChannel', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  // integration_test_id: 9d80fd54-9e6d-454d-8344-6f9436b8e495
-  test('it should create a channel for community', async () => {
-    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
-
-    const {
-      channels: [expected],
-    } = convertRawChannelPayload(rawChannelPayload);
-
-    const res = await createChannel({ type: 'community' });
-
-    expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(expected);
-  });
-
-  // integration_test_id: cef520ab-027d-4c5b-836c-a7f63ddc5146
-  test('it should create a channel for live', async () => {
-    client.http.post = jest.fn().mockResolvedValueOnce({ data: liveChannelPayload });
-
-    const {
-      channels: [expected],
-    } = convertRawChannelPayload(liveChannelPayload);
-
-    const res = await createChannel({ type: 'live' });
-
-    expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(expected);
-  });
-
-  // integration_test_id: 11a43612-ff6f-4262-874c-4419d342cff1
-  test('it should create a channel for conversation', async () => {
-    client.http.post = jest.fn().mockResolvedValueOnce({ data: conversationChannelPayload });
-
-    const {
-      channels: [expected],
-    } = convertRawChannelPayload(conversationChannelPayload);
-
-    const res = await createChannel({ type: 'conversation' });
-
-    expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(expected);
-  });
-
-  test('it should add channel to cache', async () => {
-    enableCache();
-
-    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
-    const { channelId } = channelPayload.channels[0];
-
-    const {
-      channels: [expected],
-    } = convertRawChannelPayload(rawChannelPayload);
-
-    await createChannel({ type: 'community' });
-    const data = pullFromCache(['channel', 'get', channelId]);
-
-    expect(data).toBeDefined();
-    expect(data?.data).toStrictEqual(expected);
-
-    disableCache();
-  });
-
-  test('it should call conversation channel with /conversation api', async () => {
-    const mockFn = jest.fn();
-    client.http.post = mockFn.mockResolvedValueOnce(resPayload);
-    const expected = '/api/v3/channels/conversation';
-    const expectedPayload = { type: 'conversation', isDistinct: true };
-
-    await createChannel({ type: 'conversation' });
-    const [received, receivedPayload] = mockFn.mock.lastCall;
-
-    expect(received).toBe(expected);
-    expect(receivedPayload).toStrictEqual(expectedPayload);
-  });
-
-  test('it should return an error', async () => {
-    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
-
-    await expect(createChannel({ type: 'conversation' })).rejects.toThrow('error');
-  });
-});