@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-bef76fa.0

package/src/channel/events/onChannelLeft.ts

@@ -1,8 +1,9 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
@@ -20,18 +21,14 @@ import { ingestInCache } from '~/core/cache'
  * @category Channel Events
  */
 export const onChannelLeft = (callback: Amity.Listener<Amity.Channel>) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.channels[0])
-  }
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'onChannelLeft',
-    'v3.channel.didLeave',
-    filter
-  )
-}
+  return createEventSubscriber(client, 'onChannelLeft', 'v3.channel.didLeave', filter);
+};

package/src/channel/events/onChannelMemberAdded.ts

@@ -0,0 +1,38 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberAdded((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberAdded = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'member')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberAdded', 'v3.channel.didAddUsers', filter);
+};

package/src/channel/events/onChannelMemberBanned.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberBanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberBanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been banned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberBanned = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'banned')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberBanned', 'v3.channel.didBan', filter);
+};

package/src/channel/events/onChannelMemberRead.ts

@@ -0,0 +1,38 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberRead } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRead((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been read from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberRead = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+
+    ingestInCache(preparedPayload);
+    callback(preparedPayload.channels[0], preparedPayload.channelUsers[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberRead', 'v3.channel.didMarkSeen', filter);
+};

package/src/channel/events/onChannelMemberRemoved.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRemoved((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberRemoved = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'onChannelMemberRemoved',
+    'v3.channel.didRemoveUsers',
+    filter,
+  );
+};

package/src/channel/events/onChannelMemberUnbanned.ts

@@ -0,0 +1,39 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberUnbanned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberUnbanned((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been unbanned from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberUnbanned = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const channelPayload = prepareChannelPayload(payload);
+    const preparedPayload = prepareMembershipPayload(channelPayload, 'channelUsers');
+    const { channels, channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+    callback(channels[0], channelUsers.find(cu => cu.membership === 'none')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberUnbanned', 'v3.channel.didUnban', filter);
+};

package/src/channel/events/onChannelUpdated.ts

@@ -1,8 +1,9 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
@@ -20,18 +21,14 @@ import { ingestInCache } from '~/core/cache'
  * @category Channel Events
  */
 export const onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.channels[0])
-  }
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'onChannelUpdated',
-    'v3.channel.didUpdate',
-    filter
-  )
-}
+  return createEventSubscriber(client, 'onChannelUpdated', 'v3.channel.didUpdate', filter);
+};

package/src/channel/events/tests/onChannelMemberBanned.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser5,
+  user11,
+  user13,
+} from '~/utils/tests';
+
+import { onChannelMemberBanned } from '../onChannelMemberBanned';
+
+describe('onChannelMemberBanned event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser5],
+    channels: [channel11],
+    files: [],
+    users: [user11, user13],
+  };
+
+  test('it should call callback with channel and banned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    client.emitter.emit('v3.channel.didBan', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser5, user: user13 });
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didBan', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/events/tests/onChannelMemberRead.test.ts

@@ -0,0 +1,56 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  user11,
+} from '~/utils/tests';
+
+import { onChannelMemberRead } from '../onChannelMemberRead';
+
+describe('onChannelMemberRead event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelPayload = {
+    channelUsers: [channelUser1],
+    channels: [channel11],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback with channel and read member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberRead(callback);
+    client.emitter.emit('v3.channel.didMarkSeen', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser1, user: user11 });
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberRead(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didMarkSeen', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/events/tests/onChannelMemberUnbanned.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser3,
+  user11,
+  user12,
+} from '~/utils/tests';
+
+import { onChannelMemberUnbanned } from '../onChannelMemberUnbanned';
+
+describe('onChannelMemberBanned event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser3],
+    channels: [channel11],
+    files: [],
+    users: [user11, user12],
+  };
+
+  test('it should call callback with channel and unbanned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberUnbanned(callback);
+    client.emitter.emit('v3.channel.didUnban', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser3, user: user12 });
+  });
+
+  test('it should return an Unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberUnbanned(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didUnban', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/observers/index.ts

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

package/src/channel/observers/liveChannelMembers.ts

@@ -0,0 +1,185 @@
+/* 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,
+  onChannelMemberBanned,
+  onChannelMemberUnbanned,
+  onChannelMemberRead,
+} 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);
+
+    if (params.memberships) {
+      /*
+       * even though membership includes muted as a possible value
+       * when querying the server.
+       * Muted is specified under seperarte property namely isMuted
+       * Hence why I've seperately checked for it's equality
+       */
+      if (params.memberships.some(m => ['member', 'banned'].includes(m))) {
+        channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
+      }
+
+      if (params.memberships.includes('muted')) {
+        channelMembers = filterByPropEquality(channelMembers, 'isMuted', true);
+      }
+    }
+
+    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: Amity.ChannelMemberActionType,
+  ) => {
+    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])];
+    }
+
+    if (action === 'onMemberRemoved') {
+      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')),
+    onChannelMemberBanned((_, member) => realtimeRouter(member, 'onChannelMemberBanned')),
+    onChannelMemberUnbanned((_, member) => realtimeRouter(member, 'onChannelMemberUnbanned')),
+    onChannelMemberRead((_, member) => realtimeRouter(member, 'onMemberRead')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};