@amityco/ts-sdk 0.0.1-beta.29 → 0.0.1-beta.30

package/dist/utils/tests/dummy/channel.d.ts

@@ -6,28 +6,54 @@ export declare const channel12: Amity.Channel;
 export declare const channel21: Amity.Channel;
 export declare const channelUser1: Amity.Membership<'channel'>;
 export declare const channelUser2: Amity.Membership<'channel'>;
+export declare const channelUser3: Amity.Membership<'channel'>;
+export declare const channelUser4: Amity.Membership<'channel'>;
 export declare const channelQueryResponse: {
     data: {
+        paging: {
+            previous: string;
+            next: string;
+        };
         channels: Amity.Channel<any>[];
         channelUsers: never[];
         files: never[];
         users: never[];
+    };
+};
+export declare const channelQueryResponsePage2: {
+    data: {
         paging: {
             previous: string;
             next: string;
         };
+        channels: Amity.Channel<any>[];
+        channelUsers: never[];
+        files: never[];
+        users: never[];
     };
 };
-export declare const channelQueryResponsePage2: {
+export declare const channelUserQueryResponse: {
     data: {
+        paging: {
+            previous: string;
+            next: string;
+        };
         channels: Amity.Channel<any>[];
-        channelUsers: never[];
-        files: never[];
+        channelUsers: Amity.Membership<"channel">[];
         users: never[];
+        files: never[];
+    };
+};
+export declare const channelUserQueryResponsePage2: {
+    data: {
         paging: {
             previous: string;
             next: string;
         };
+        channels: Amity.Channel<any>[];
+        channelUsers: Amity.Membership<"channel">[];
+        users: never[];
+        files: never[];
     };
 };
 //# sourceMappingURL=channel.d.ts.map

package/dist/utils/tests/dummy/channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/channel.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,UAK/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,UAK/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,UAK/B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAO7B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAO7B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAO7B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAYpD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAKpD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;CAWhC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;CAWrC,CAAC"}
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/channel.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,UAO/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,UAO/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,UAK/B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAK7B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAI7B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,OAO7B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAYpD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAKpD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAapD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,SAAS,CAGpD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;CAQhC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;CAQrC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;CAQpC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;CAQzC,CAAC"}

package/dist/utils/tests/utils.d.ts

@@ -1,2 +1,3 @@
 export declare const encodeJson: (value: Record<string, any>) => string;
+export declare const pause: (ms?: number) => Promise<unknown>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/tests/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,UAAW,OAAO,MAAM,EAAE,GAAG,CAAC,WAAkC,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,UAAW,OAAO,MAAM,EAAE,GAAG,CAAC,WAAkC,CAAC;AAOxF,eAAO,MAAM,KAAK,mCAGd,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.29",
+  "version": "0.0.1-beta.30",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@react-native-async-storage/async-storage": "^1.17.7",
     "agentkeepalive": "^4.2.1",
-    "axios": "0.21.1",
+    "axios": "^0.27.2",
     "debug": "^4.3.4",
     "js-base64": "^3.7.2",
     "mitt": "^3.0.0",

package/src/@types/domains/channel.ts

@@ -35,6 +35,7 @@ declare global {
 
       memberCount?: number;
       messageCount?: number;
+      moderatorMemberCount?: number;
 
       lastActivity?: Amity.timestamp;
 
@@ -64,5 +65,23 @@ declare global {
       Amity.Channel['channelId'],
       Pick<QueryChannels, 'page'>
     >;
+
+    type QueryChannelMembers = {
+      channelId: Amity.Channel['channelId'];
+      memberships?: Array<Exclude<Amity.Membership<'channel'>['membership'], 'none'> | 'muted'>;
+      roles?: string[];
+      sortBy?: 'firstCreated' | 'lastCreated';
+      search?: string;
+      page?: Amity.Page;
+    };
+
+    type ChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryChannelMembers, 'page'>
+    >;
+
+    type ChannelMembersLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Membership<'channel'>['userId'],
+      Pick<QueryChannelMembers, 'page'>
+    >;
   }
 }

package/src/channel/api/queryChannelMembers.ts

@@ -19,14 +19,9 @@ import { prepareChannelPayload } from '../utils';
  * @category Channel API
  * @async
  * */
-export const queryChannelMembers = async (query: {
-  channelId: string;
-  memberships?: ('muted' | 'banned' | 'member')[];
-  roles?: string[];
-  sortBy?: 'firstCreated' | 'lastCreated';
-  search?: string;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
+export const queryChannelMembers = async (
+  query: Amity.QueryChannelMembers,
+): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 

package/src/channel/observers/index.ts

@@ -1,3 +1,4 @@
 export * from './observeChannel';
 export * from './observeChannels';
 export * from './liveChannels';
+export * from './liveChannelMembers';

package/src/channel/observers/liveChannelMembers.ts

@@ -0,0 +1,159 @@
+/* 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,
+  sortByFirstCreated,
+  filterByPropInclusion,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onChannelMemberAdded, onChannelMemberRemoved } from '../events';
+import { queryChannelMembers } from '../api';
+
+/**
+ * ```js
+ * import { liveChannelMembers } from '@amityco/ts-sdk'
+ *
+ * let channelMembers = []
+ * const unsub = liveChannelMembers({
+ *   channelId: Amity.Channel['channelId'],
+ * }, response => merge(channelMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @param params for querying channel users
+ * @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 channel users
+ *
+ * @category Channel Live Collection
+ */
+export const liveChannelMembers = (
+  params: Amity.ChannelMembersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveChannelMembers(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 = ['channelUsers', 'collection', { channelId: params.channelId }];
+
+  const responder = (data: Amity.ChannelMembersLiveCollectionCache) => {
+    let channelMembers: Amity.Membership<'channel'>[] =
+      data.data
+        .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    channelMembers = filterByPropEquality(channelMembers, 'roles', params.roles);
+    channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
+
+    if (params.search) {
+      const containsMatcher = new RegExp(params.search);
+      channelMembers = channelMembers.filter(m => m.userId.match(containsMatcher));
+    }
+
+    // sort, 'lastCreated' is the default sort order
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+    channelMembers = channelMembers.sort(
+      sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+    );
+
+    callback({
+      onNextPage: onFetch,
+      data: channelMembers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (
+    channelMember: Amity.Membership<'channel'>,
+    action: 'onMemberAdded' | 'onMemberRemoved',
+  ) => {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    const channelMemberCacheId = getResolver('channelUsers')({
+      channelId: params.channelId,
+      userId: channelMember.userId,
+    });
+
+    if (action === 'onMemberAdded') {
+      collection.data = [...new Set([channelMemberCacheId, ...collection.data])];
+    } else {
+      collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+
+    const channelMembers = collection?.data ?? [];
+
+    if (channelMembers.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryChannelMembers, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: channelMembers,
+        };
+
+        if (result) {
+          data.data = [...new Set([...channelMembers, ...result.map(getResolver('channelUsers'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')),
+    onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/tests/liveChannelMembers.test.ts

@@ -0,0 +1,165 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channelUser1,
+  channelUser4,
+  channelUserQueryResponse,
+  channelUserQueryResponsePage2,
+  channel11,
+  pause,
+} from '~/utils/tests';
+import { liveChannelMembers } from '../liveChannelMembers';
+import { prepareChannelPayload } from '../../utils';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Membership<'channel'>[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+describe('liveChannelMembers', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { channelId } = channel11;
+
+  test('it should return channel members collection', async () => {
+    // mock response of queryChannels and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+
+    const snapshot = getSnapshot();
+    snapshot.data = channelUserQueryResponse.data.channelUsers;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+  });
+
+  const filters: [string, Amity.ChannelMembersLiveCollection, Amity.Membership<'channel'>[]][] = [
+    [
+      'roles',
+      { channelId, roles: channelUserQueryResponse.data.channelUsers[1].roles },
+      [channelUserQueryResponse.data.channelUsers[1]],
+    ],
+    [
+      'searched term',
+      { channelId, search: 'use' },
+      [channelUserQueryResponse.data.channelUsers[1]],
+    ],
+    [
+      'memberships',
+      { channelId, memberships: ['member'] },
+      [channelUserQueryResponse.data.channelUsers[0]],
+    ],
+  ];
+
+  test.each(filters)('it should filter channelUsers by %s', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers(params, callback);
+    await pause();
+
+    const snapshot = getSnapshot();
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(snapshot));
+
+    snapshot.loading = false;
+    snapshot.data = expected;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(channelUserQueryResponse)
+      .mockResolvedValueOnce(channelUserQueryResponsePage2);
+
+    liveChannelMembers({ channelId }, 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();
+
+    const payload = prepareChannelPayload(channelUserQueryResponse.data);
+    const payload2 = prepareChannelPayload(channelUserQueryResponsePage2.data);
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2.channelUsers, ...payload.channelUsers];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events, Amity.Membership<'channel'>][] = [
+    [
+      'it should add new member to collection onMemberAdded',
+      'v3.channel.didAddUsers',
+      channelUser4,
+    ],
+    [
+      'it should remove channel memeber from collection onMemberRemoved',
+      'v3.channel.didRemoveUsers',
+      channelUser1,
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, channelUser) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    liveChannelMembers({ channelId }, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      channels: [channel11],
+      channelUsers: [channelUser],
+      users: [],
+      files: [],
+    });
+
+    const payload = prepareChannelPayload(channelUserQueryResponse.data);
+
+    snapshot.loading = false;
+    // get data based on event
+    if (event === 'v3.channel.didAddUsers') {
+      snapshot.data = [channelUser, ...payload.channelUsers];
+    } else {
+      const deletePayload = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
+      snapshot.data = deletePayload;
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/channel/observers/tests/liveChannels.test.ts

@@ -2,13 +2,13 @@ import { disableCache, enableCache } from '~/cache/api';
 
 import { liveChannels } from '../liveChannels';
 import { queryChannels } from '~/channel/api';
+import { prepareChannelPayload } from '../../utils/prepareChannelPayload';
 
 import {
   client,
   connectClient,
   disconnectClient,
   channel11,
-  channel12,
   channelUser1,
   channelQueryResponse,
   channelQueryResponsePage2,
@@ -53,7 +53,10 @@ describe('liveChannels', () => {
 
     expect(callback).toHaveBeenCalledTimes(2);
 
-    snapshot.data = channelQueryResponse.data.channels;
+    // cause we apply prepareChannelPayload on channel raw data from server
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+
+    snapshot.data = payload.channels;
     snapshot.loading = false;
 
     expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
@@ -115,12 +118,12 @@ describe('liveChannels', () => {
     // 4 -> becuase 1 local & server call each per call (2)
     expect(callback).toHaveBeenCalledTimes(4);
 
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+    const payload2 = prepareChannelPayload(channelQueryResponsePage2.data);
+
     const snapshot = getSnapshot();
     snapshot.loading = false;
-    snapshot.data = [
-      ...channelQueryResponsePage2.data.channels,
-      ...channelQueryResponse.data.channels,
-    ];
+    snapshot.data = [...payload2.channels, ...payload.channels];
 
     expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
   });
@@ -153,19 +156,24 @@ describe('liveChannels', () => {
       files: [],
     });
 
+    const payload = prepareChannelPayload(channelQueryResponse.data);
+    const deletePayload = payload.channels.filter(
+      channel => channel.channelId !== channel11.channelId,
+    );
+
     snapshot.loading = false;
     // get data based on event
     switch (event) {
       case 'v3.channel.didCreate':
-        snapshot.data = [channel, channel11, channel12];
+        snapshot.data = [channel, ...payload.channels];
         break;
 
       case 'v3.channel.didUpdate':
-        snapshot.data = channelQueryResponse.data.channels;
+        snapshot.data = payload.channels;
         break;
 
       default:
-        snapshot.data = [channel12];
+        snapshot.data = deletePayload;
     }
 
     expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));

package/src/client/api/isConnected.ts

@@ -18,7 +18,7 @@ export const isConnected = (): boolean => {
 
   return !!(
     client.userId &&
-    client.http.defaults.headers.common?.Authorization?.length &&
+    String(client.http.defaults.headers.common?.Authorization)?.length &&
     client.ws.connected
   );
 };

package/src/core/query/filtering.ts

@@ -17,3 +17,9 @@ export const filterByPropEquality = <T = Record<string, unknown>>(
   key: keyof T,
   value: any,
 ) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+
+export const filterByPropInclusion = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any[] | undefined,
+) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);

package/src/core/query/query.ts

@@ -129,18 +129,17 @@ export const queryOptions = (
  *
  * @hidden
  */
-const isEmpty = (local: any) => {
+const isEmpty = (local: unknown) => {
   // if it's supposed to be a single object, it'd be undefined
   if (!local) return true;
 
   // it's a paged query, the 1st cell of the array would be empty
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   if (isPaged(local) && isEmpty(local.data)) {
     return true;
   }
 
   // if it's a item collection, it'd have no keys
-  if (!Object.keys(local).length) return true;
+  if (typeof local === 'object' && !Object.keys(local).length) return true;
 
   return false;
 };