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

package/src/community/events/test/utils.test.ts

@@ -10,7 +10,11 @@ import {
   user11,
 } from '~/utils/tests';
 
-import { createCommunityEventSubscriber, createCommunityMemberEventSubscriber } from '../utils';
+import {
+  createCommunityEventSubscriber,
+  createCommunityMemberEventSubscriber,
+  updateMembershipStatus,
+} from '../utils';
 
 const event = 'community.created';
 const communityToCreate = community11;
@@ -115,7 +119,7 @@ describe('createCommunityMemberEventSubscriber', () => {
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(communityToAddUser, addedUser);
+    expect(callback).toHaveBeenCalledWith({ ...communityToAddUser, isJoined: true }, addedUser);
   });
 
   test('it should trigger callback with correctly params when cache is enabled', () => {
@@ -128,7 +132,7 @@ describe('createCommunityMemberEventSubscriber', () => {
     unsub();
 
     expect(callback).toHaveBeenCalled();
-    expect(callback).toHaveBeenCalledWith(communityToAddUser, addedUser);
+    expect(callback).toHaveBeenCalledWith({ ...communityToCreate, isJoined: true }, addedUser);
 
     disableCache();
   });
@@ -156,3 +160,48 @@ describe('createCommunityMemberEventSubscriber', () => {
     disableCache();
   });
 });
+
+describe('updateMembershipStatus', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const communities = [
+    {
+      communityId: 'test-membership',
+    } as Amity.Community,
+  ];
+
+  const getCommunityUsers = (membership = 'member') => [
+    {
+      communityId: 'test-membership',
+      communityMembership: membership,
+      userId: client?.userId || 'test',
+    } as Amity.Membership<'community'>,
+    {
+      communityId: 'test-membership',
+      communityMembership: 'member',
+      userId: 'some-other-user',
+    } as Amity.Membership<'community'>,
+  ];
+
+  test('it should update isJoined status to true if membership member', () => {
+    const expected = { ...communities[0], isJoined: true };
+    const recieved = updateMembershipStatus(communities, getCommunityUsers())[0];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+
+  test('it should update isJoined status to true if membership banned', () => {
+    const expected = { ...communities[0], isJoined: true };
+    const recieved = updateMembershipStatus(communities, getCommunityUsers('banned'))[0];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+
+  test('it should update isJoined status to false if membership none', () => {
+    const expected = { ...communities[0], isJoined: false };
+    const recieved = updateMembershipStatus(communities, getCommunityUsers('none'))[0];
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});

package/src/community/events/utils.ts

@@ -1,4 +1,5 @@
 import { getActiveClient } from '~/client/api';
+import { getActiveUser } from '~/client/api/activeUser';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
@@ -35,6 +36,43 @@ export const createCommunityEventSubscriber = (
   return createEventSubscriber(client, event, event, filter);
 };
 
+/*
+ * verifies membership status
+ */
+function isMember(membership: Amity.Membership<'community'>['communityMembership']): boolean {
+  return membership !== 'none';
+}
+
+/*
+ * checks if currently logged in user is part of the community
+ */
+function isCurrentUserPartOfCommunity(
+  c: Amity.Community,
+  m: Amity.Membership<'community'>,
+): boolean {
+  const { userId } = getActiveUser();
+
+  return c.communityId === m.communityId && m.userId === userId;
+}
+
+/*
+ * For mqtt events server will not send user specific data as it's broadcasted
+ * to multiple users. Althought this can be calculated, it's not scalable. Hence
+ * the client SDK needs to calculate this info
+ */
+export function updateMembershipStatus(
+  communities: Amity.Community[],
+  communityUsers: Amity.Membership<'community'>[],
+): Amity.Community[] {
+  return communities.map(c => {
+    const isJoined = communityUsers.some(
+      m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership),
+    );
+
+    return { ...c, isJoined };
+  });
+}
+
 function hasPermission(
   member: Amity.Membership<'community'>,
   payload: {
@@ -88,7 +126,18 @@ export const createCommunityMemberEventSubscriber = (
 
   const filter = (payload: Amity.CommunityMembershipPayload) => {
     const communityPayload = unpackCommunityPayload(payload);
+    const { communities } = communityPayload;
+
     const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
+    const { communityUsers } = preparedPayload;
+
+    /*
+     * community.isJoined is not part of the communityMembership payload, and needs
+     * to be calculated based on the communityMembership value
+     */
+    const communitiesWithMembership = updateMembershipStatus(communities, communityUsers);
+
+    preparedPayload.communities = communitiesWithMembership;
 
     if (!client.cache) {
       // TODO: here we are missing specific properties here!

package/src/community/observers/index.ts

@@ -1 +1,2 @@
 export * from './observeCommunity';
+export * from './liveCommunities';

package/src/community/observers/liveCommunities.ts

@@ -0,0 +1,188 @@
+/* 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,
+  sortByDisplayName,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import {
+  onCommunityCreated,
+  onCommunityDeleted,
+  onCommunityUpdated,
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserChanged,
+} from '../events';
+import { queryCommunities } from '../api';
+
+/**
+ * ```js
+ * import { liveCommunities } from '@amityco/ts-sdk'
+ *
+ * let communities = []
+ * const unsub = liveCommunities({
+ *   displayName: Amity.Community['displayName'],
+ * }, response => merge(communities, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Community}s
+ *
+ * @param params for querying communities
+ * @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 communities
+ *
+ * @category Community Live Collection
+ */
+export const liveCommunities = (
+  params: Amity.CommunityLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Community>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveCommunities(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 = ['community', 'collection', {}];
+
+  const responder = (data: Amity.CommunityLiveCollectionCache) => {
+    let communities: Amity.Community[] =
+      data.data
+        .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    communities = filterByPropEquality(communities, 'isDeleted', params.isDeleted);
+    communities = filterByPropEquality(communities, 'displayName', params.displayName);
+
+    if (params.categoryId) {
+      communities = communities.filter(c => c.categoryIds?.includes(params.categoryId!));
+    }
+
+    if (params.tags) {
+      communities = communities.filter(c => c.tags?.some(t => params.tags?.includes(t)));
+    }
+
+    if (params.membership === 'member') {
+      communities = filterByPropEquality(communities, 'isJoined', true);
+    }
+
+    if (params.membership === 'notMember') {
+      communities = filterByPropEquality(communities, 'isJoined', false);
+    }
+
+    const sortBy = params.sortBy || 'lastCreated';
+
+    if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+      communities = communities.sort(
+        sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+      );
+    }
+
+    /*
+     * The server returns communities with empty | null displayName's first before
+     * returning sorted list of communities with displayNames
+     *
+     * This section needs to be updated as displayNames can be null as well
+     */
+    if (sortBy === 'displayName') {
+      communities = communities
+        // this needs to be aligned with the backend data type
+        .map(c => (c.displayName ? c : { ...c, displayName: '' }))
+        // @ts-ignore
+        .sort(sortByDisplayName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: communities,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (_: Amity.CommunityActionType) => (community: Amity.Community) => {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    /*
+     * Simply update collection and let responder decide what to do with data
+     */
+    collection.data = [...new Set([community.communityId, ...collection.data])];
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(cacheKey)?.data;
+
+    const communities = collection?.data ?? [];
+
+    if (communities.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryCommunities, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: communities,
+        };
+
+        if (result) {
+          data.data = [...new Set([...communities, ...result.map(getResolver('community'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommunityCreated(realtimeRouter('onCreate')),
+    onCommunityDeleted(realtimeRouter('onDelete')),
+    onCommunityUpdated(realtimeRouter('onUpdate')),
+    onCommunityJoined(realtimeRouter('onJoin')),
+    onCommunityLeft(realtimeRouter('onLeft')),
+    onCommunityUserChanged(realtimeRouter('onMemberCountChanged')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveCommunities(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/community/observers/tests/liveCommunities.test.ts

@@ -0,0 +1,284 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  communityQueryResponse,
+  communityQueryResponsePage2,
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  communityUser11,
+} from '~/utils/tests';
+
+import { liveCommunities } from '../liveCommunities';
+
+import { unpackCommunityPayload } from '../../utils';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.Community[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+const { paging, ...payload } = communityQueryResponse.data;
+const { paging: paging2, ...payload2 } = communityQueryResponsePage2.data;
+
+const community1 = unpackCommunityPayload(payload).communities[0];
+const community2 = unpackCommunityPayload(payload).communities[1];
+
+describe('liveCommunities', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return community collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    liveCommunities({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: unpackCommunityPayload(payload).communities,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    liveCommunities({}, () => undefined);
+    await pause();
+    liveCommunities({}, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: unpackCommunityPayload(payload).communities,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: unpackCommunityPayload(payload).communities,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  const filters: [string, Amity.CommunityLiveCollection, Amity.Community[]][] = [
+    ['deleted', { isDeleted: true }, [community1]],
+    ['categoryId', { categoryId: 'test-category-id' }, [community1]],
+    ['displayName', { displayName: 'community 1' }, [community1]],
+    ['tagged', { tags: ['test-community-tag'] }, [community1]],
+    ['member', { membership: 'member' }, [community1]],
+    ['not member', { membership: 'notMember' }, [community2]],
+    ['all membership', { membership: 'all' }, [community1, community2]],
+  ];
+
+  test.each(filters)('it should filter by %s communities', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+    liveCommunities(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(communityQueryResponse)
+      .mockResolvedValueOnce(communityQueryResponsePage2);
+
+    liveCommunities({}, 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: unpackCommunityPayload(payload).communities,
+        }),
+      ),
+    );
+  });
+
+  describe('events', () => {
+    const newCommunityPayload = {
+      ...communityQueryResponse.data.communities[0],
+      communityId: 'new-community',
+      isDeleted: false,
+    };
+    const newCommunity = unpackCommunityPayload({ communities: [newCommunityPayload] })
+      .communities[0];
+
+    const communityPayload = {
+      communities: [communityQueryResponse.data.communities[0]],
+      communityUsers: [communityUser11],
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.CommunityPayload, Amity.Community[]][] = [
+      [
+        'it should add new community to collection onCreate',
+        'community.created',
+        { communities: [newCommunityPayload] },
+        [newCommunity, community2],
+      ],
+      [
+        'it should update community in collection onUpdate',
+        'community.updated',
+        { communities: [{ ...newCommunityPayload, communityId: community1.communityId }] },
+        [{ ...newCommunity, communityId: community1.communityId }, community2],
+      ],
+      [
+        'it should remove community from collection onDelete',
+        'community.deleted',
+        communityPayload,
+        [community2],
+      ],
+    ];
+
+    test.each(cases)('%s', async (test, event, communityPayload, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(communityQueryResponse);
+
+      liveCommunities({ isDeleted: false }, callback);
+      await pause();
+
+      client.emitter.emit(event, communityPayload);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+
+    const joinCommunityPayload = {
+      ...communityQueryResponse.data.communities[0],
+      communityId: 'joining-community',
+      isDeleted: false,
+    };
+    const joinedCommunity = unpackCommunityPayload({ communities: [joinCommunityPayload] })
+      .communities[0];
+
+    const joiningUser: Amity.MembershipRaw<'community'> = {
+      ...communityUser11,
+      userId: 'test',
+      communityId: 'joining-community',
+      communityMembership: 'member',
+    };
+
+    const memberEvents: [
+      string,
+      Amity.CommunityLiveCollection,
+      keyof Amity.Events,
+      Amity.CommunityPayload,
+      Amity.Community[],
+    ][] = [
+      [
+        'it should add new community to collection onJoin',
+        { membership: 'member' },
+        'community.joined',
+        { communities: [joinCommunityPayload], communityUsers: [joiningUser] },
+        [joinedCommunity, community1],
+      ],
+      [
+        'it should not add new member to community collection onJoin if membership:not member',
+        { membership: 'notMember' },
+        'community.joined',
+        { communities: [joinCommunityPayload], communityUsers: [joiningUser] },
+        [],
+      ],
+      [
+        'it should update community in collection onLeft',
+        { membership: 'member' },
+        'community.left',
+        { ...communityPayload, communities: [{ ...community1, isJoined: false }] },
+        [],
+      ],
+      [
+        'it should add new community in collection onLeft and if membership:not member',
+        { membership: 'notMember' },
+        'community.left',
+        { ...communityPayload, communities: [{ ...community1, isJoined: false }] },
+        [{ ...community1, isJoined: false }],
+      ],
+    ];
+
+    test.each(memberEvents)('%s', async (test, params, event, communityPayload, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(communityQueryResponsePage2);
+
+      liveCommunities(params, callback);
+      await pause();
+
+      client.emitter.emit(event, communityPayload);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+  });
+});

package/src/core/query/sorting.ts

@@ -15,6 +15,14 @@ export const sortByDisplayName: SortingFunc<{ displayName: string }> = (
   return a < b ? -1 : 1;
 };
 
+/**
+ * Alphabetic sorting of objects having a name
+ */
+export const sortByName: SortingFunc<{ name: string }> = ({ name: a }, { name: b }) => {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+};
+
 /**
  * Sorting a collection by their apparition order (oldest first)
  */

package/src/core/transports/http.ts

@@ -1,5 +1,4 @@
 import axios from 'axios';
-import qs from 'qs';
 import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 
 import { ASCError } from '~/core/errors';
@@ -7,14 +6,6 @@ import { ASCError } from '~/core/errors';
 import { fireEvent } from '../events';
 import { unwrapPayload } from './utils';
 
-/**
- * Axios param serializer (for querystring)
- * @hidden
- */
-export const stringify = (params: Record<string, unknown>): string => {
-  return qs.stringify(params, { arrayFormat: 'brackets' });
-};
-
 /**
  * Creates a pre-configured axios instance
  *
@@ -36,7 +27,14 @@ export const createHttpTransport = (endpoint: string) => {
     baseURL: endpoint,
     httpAgent: new HttpAgent(options),
     httpsAgent: new HttpsAgent(options),
-    paramsSerializer: stringify,
+    /*
+     * If paramSerializer is required, use the serialize option to stringify
+     * params. The encode option will pass complex params as string only whereas
+     * the serialize option will pass params in the format Record<string, any>
+     *
+     * For more details:
+     * https://github.com/axios/axios#request-config
+     */
   });
 
   instance.interceptors.request.use(config => {
@@ -59,8 +57,6 @@ export const createHttpTransport = (endpoint: string) => {
     response => response,
     error => {
       const { response } = error;
-      // eslint-disable-next-line no-console
-      console.error(response?.data ?? error);
 
       // handle unauthorized request
       if (response.data.code === Amity.ServerError.UNAUTHORIZED) {
@@ -78,7 +74,15 @@ export const createHttpTransport = (endpoint: string) => {
         );
       }
 
-      if (response?.data) unwrapPayload(response.data);
+      // if it's an error with status in the response payload,
+      // then it's an expected error.
+      if (response?.data?.status) {
+        unwrapPayload(response?.data);
+      }
+      // unexpected error.
+      else {
+        throw new Error(response?.data ?? error);
+      }
     },
   );