@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.38

package/src/category/api/queryCategories.ts

@@ -20,11 +20,9 @@ import { getResolver } from '~/core/model';
  * @category Category API
  * @async
  * */
-export const queryCategories = async (query?: {
-  sortBy?: 'lastCreated' | 'firstCreated' | 'name';
-  isDeleted?: Amity.Category['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
+export const queryCategories = async (
+  query?: Amity.QueryCategories,
+): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
   const client = getActiveClient();
   client.log('category/queryCategories', query);
 

package/src/category/observers/index.ts

@@ -0,0 +1 @@
+export * from './liveCategories';

package/src/category/observers/liveCategories.ts

@@ -0,0 +1,141 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastCreated,
+  sortByName,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { queryCategories } from '../api';
+
+/**
+ * ```js
+ * import { liveCategories } from '@amityco/ts-sdk'
+ *
+ * let categories = []
+ * const unsub = liveCategories({}, response => merge(categories, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Category}s
+ *
+ * @param params for querying categories
+ * @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 categories
+ *
+ * @category Category Live Collection
+ */
+export const liveCategories = (
+  params: Amity.CategoryLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Category>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveCategories(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 = ['category', 'collection', {}];
+
+  const responder = (data: Amity.CategoryLiveCollectionCache) => {
+    let categories: Amity.Category[] =
+      data.data
+        .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    categories = filterByPropEquality(categories, 'isDeleted', params.isDeleted);
+
+    switch (params.sortBy) {
+      case 'firstCreated':
+        categories = categories.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        categories = categories.sort(sortByLastCreated);
+        break;
+
+      default:
+        categories = categories.sort(sortByName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: categories,
+      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 = () => {
+    const collection = pullFromCache<Amity.CategoryLiveCollectionCache>(cacheKey)?.data;
+
+    const categories = collection?.data ?? [];
+
+    if (categories.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCategories, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: categories,
+        };
+
+        if (result) {
+          data.data = [...new Set([...categories, ...result.map(getResolver('category'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(() => {
+    // @TODO -> update once observers added
+  });
+
+  onFetch();
+
+  return () => {
+    log(`liveCategories(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/category/observers/tests/liveCategories.test.ts

@@ -0,0 +1,147 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  categoryQueryResponse,
+  categoryQueryResponsePage2,
+  category11,
+  category12,
+  category13,
+} from '~/utils/tests';
+import { sortByName } from '~/core/query';
+
+import { liveCategories } from '../liveCategories';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Category[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('live Caategories', () => {
+  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);
+
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(categoryQueryResponse);
+
+    liveCategories({}, () => undefined);
+    await pause();
+    liveCategories({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.categories,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CategoryLiveCollection, Amity.Category[]][] = [
+    ['deleted', { isDeleted: true }, [category13]],
+    ['not deleted', { isDeleted: 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);
+
+    liveCategories(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);
+
+    liveCategories({}, 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/channel/api/tests/createChannel.test.ts

@@ -1,20 +1,44 @@
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
-import { channelPayload, client } from '~/utils/tests';
+import {
+  channelPayload,
+  client,
+  conversationChannelPayload,
+  liveChannelPayload,
+} from '~/utils/tests';
 import { prepareChannelPayload } from '~/channel/utils';
 import { createChannel } from '../createChannel';
 
 const resPayload = { data: channelPayload };
 
 describe('createChannel', () => {
-  const channel = prepareChannelPayload(channelPayload).channels[0];
-
-  test('it should create a channel', async () => {
+  // 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 res = await createChannel({ type: 'community' });
 
     expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(channel);
+    expect(res.data).toStrictEqual(prepareChannelPayload(channelPayload).channels[0]);
+  });
+
+  // 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 res = await createChannel({ type: 'live' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(liveChannelPayload).channels[0]);
+  });
+
+  // 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 res = await createChannel({ type: 'conversation' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(prepareChannelPayload(conversationChannelPayload).channels[0]);
   });
 
   test('it should add channel to cache', async () => {
@@ -27,7 +51,7 @@ describe('createChannel', () => {
     const data = pullFromCache(['channel', 'get', channelId]);
 
     expect(data).toBeDefined();
-    expect(data?.data).toStrictEqual(channel);
+    expect(data?.data).toStrictEqual(prepareChannelPayload(channelPayload).channels[0]);
 
     disableCache();
   });

package/src/channel/api/tests/getChannel.test.ts

@@ -12,7 +12,8 @@ const { channelId } = channelQueryResponse.data.channels[0];
 const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
 
 describe('getChannel', () => {
-  test('it should return a channel', async () => {
+  // integration_test_id: b331e01c-20db-4f17-979b-b280d8818792
+  test('it should return a valid channel', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
 
     const expected = channel;
@@ -31,6 +32,7 @@ describe('getChannel', () => {
     disableCache();
   });
 
+  // integration_test_id: da9dc3e8-01fd-4e76-a26b-ac8333a69b23
   test('it should return an error', async () => {
     client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
 

package/src/channel/api/tests/getChannels.test.ts

@@ -0,0 +1,97 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+import { client, getChannelsResponse } from '~/utils/tests';
+
+import { getChannels } from '../getChannels';
+import { prepareChannelPayload } from '~/channel/utils';
+import { ASCApiError } from '~/core/errors';
+
+const channelIds = [
+  getChannelsResponse.data.channels[0].channelId,
+  getChannelsResponse.data.channels[1].channelId,
+  getChannelsResponse.data.channels[2].channelId,
+];
+const channel = prepareChannelPayload(getChannelsResponse.data).channels;
+
+describe('getChannels', () => {
+  // integration_test_id: ced0cd3b-1714-499d-862e-0284da1c8bb1
+  test('it should return a valid channels', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getChannelsResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannels(channelIds);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getChannelsResponse);
+    await getChannels(channelIds);
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+
+    disableCache();
+  });
+
+  // integration_test_id: 344a8f3d-0e54-4eb9-850f-80283e638352
+  test('it should return an error 400400 when try to get channels by invalid channel id', async () => {
+    const error = new ASCApiError(
+      'Some channel not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValueOnce(error);
+
+    await expect(getChannels(channelIds)).rejects.toThrow(error);
+  });
+});
+
+describe('getChannels locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(
+      getChannels.locally(['non-existent-channel-1', 'non-existent-channel-2']),
+    ).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannels.locally(channelIds)).toBeUndefined();
+  });
+
+  test('it should return cachedAt same date with oldest record', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt: cachedAt + 1 });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt: cachedAt + 2 });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+});

package/src/channel/api/tests/joinChannel.test.ts

@@ -1,4 +1,5 @@
 import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
 import { getResolver } from '~/core/model';
 
 import {
@@ -19,6 +20,7 @@ describe('joinChannel', () => {
 
   const { channelId } = channel1;
 
+  // integration_test_id: efef33a8-bf09-4dfe-8ed9-e7c3615ad74d
   test('it should return channelUser', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
 
@@ -44,9 +46,66 @@ describe('joinChannel', () => {
     disableCache();
   });
 
-  test('it should throw error', async () => {
-    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+  // integration_test_id: 402a8cd8-6522-42d0-8f40-ccccae0093a1
+  test('it should throw error 400400 when user joins channel which does not exist', async () => {
+    const apiError = new ASCApiError(
+      'ChannelId Not Found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
 
-    await expect(joinChannel(channelId)).rejects.toThrow('error');
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: dcad7f35-586c-400f-8eca-2334d6d7b3e0
+  test("it should throw error 400300 when user tries to join channel in which he doesn't have permission", async () => {
+    const apiError = new ASCApiError(
+      "Can't join the conversation channel",
+      Amity.ServerError.FORBIDDEN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 8ccb81b7-a89c-486a-81ed-7371b3ef1c4f
+  test('it should throw error 400304 when user tries to join channel in which he is banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
   });
 });

package/src/channel/api/tests/leaveChannel.test.ts

@@ -0,0 +1,90 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel1,
+  user11,
+  rawChannelUser,
+  channelUserQueryResponse,
+} from '~/utils/tests';
+
+import { leaveChannel } from '../leaveChannel';
+
+describe('leaveChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel1;
+
+  // integration_test_id: 3b4408dd-0f45-4270-9384-73d9ddac4511
+  test('it should return channelUser', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await leaveChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = rawChannelUser;
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didleaveChannel = await leaveChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didleaveChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  // integration_test_id: 4f56790e-5fa0-4d04-8c20-ab0c39d0776f
+  test('it should throw error 400301 when user try to leave a channel which user is not a member', async () => {
+    const apiError = new ASCApiError(
+      'User is not member of channel',
+      Amity.ServerError.PERMISSION_DENIED,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 818d2317-e138-4d66-bdc0-bcc858580df5
+  test('it should throw error 400304 when user try to leave channel which he got banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+});