@amityco/ts-sdk 0.0.1-003998f.0

package/src/channel/events/onChannelMemberUnbanned.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+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 data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers.find(cu => cu.membership === 'none')!);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
+};

package/src/channel/events/onChannelMuted.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMuted } from '@amityco/ts-sdk'
+ * const dispose = onChannelMuted(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been muted
+ *
+ * @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 onChannelMuted = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelMuted', 'channel.setMuted', filter);
+};

package/src/channel/events/onChannelUpdated.ts

@@ -0,0 +1,34 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelUpdated } from '@amityco/ts-sdk'
+ * const dispose = onChannelUpdated(channel => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Channel} have been updated
+ *
+ * @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 onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter);
+};

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

@@ -0,0 +1,58 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser5,
+} 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: [],
+  };
+
+  test('it should call callback with channel and banned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    client.emitter.emit('channel.banned', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, channelUser5);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberBanned(callback);
+    unsub();
+
+    client.emitter.emit('channel.unbanned', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,58 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser3,
+} 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: [],
+  };
+
+  test('it should call callback with channel and unbanned member', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberUnbanned(callback);
+    client.emitter.emit('channel.unbanned', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, channelUser3);
+  });
+
+  test('it should return an Unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberUnbanned(callback);
+    unsub();
+
+    client.emitter.emit('channel.unbanned', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/observers/index.ts

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

package/src/channel/observers/liveChannelMembers.ts

@@ -0,0 +1,183 @@
+/* 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,
+} 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')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/liveChannels.ts

@@ -0,0 +1,184 @@
+/* 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,
+  filterByChannelMembership,
+  sortByLastCreated,
+  sortByDisplayName,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onChannelCreated, onChannelDeleted, onChannelMuted, onChannelUpdated } from '../events';
+import { queryChannels } from '../api';
+
+/**
+ * ```js
+ * import { liveChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = liveChannels({
+ *   displayName: Amity.Channel['displayName'],
+ * }, response => merge(channels, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel}s
+ *
+ * @param params for querying channels
+ * @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 channels
+ *
+ * @category Channel Live Collection
+ */
+export const liveChannels = (
+  params: Amity.ChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Channel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveChannels(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 = ['channel', 'collection', {}];
+
+  const responder = (data: Amity.ChannelLiveCollectionCache) => {
+    let channels: Amity.Channel[] =
+      data.data
+        .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    channels = filterByPropEquality(channels, 'isDeleted', params.isDeleted);
+    channels = filterByPropEquality(channels, 'displayName', params.displayName);
+
+    if (params.types) {
+      channels = channels.filter(c => params.types?.includes(c.type));
+    }
+
+    if (params.tags) {
+      channels = channels.filter(c => c.tags?.some(t => params.tags?.includes(t)));
+    }
+
+    if (params.excludeTags) {
+      channels = channels.filter(c => !c.tags?.some(t => params.excludeTags?.includes(t)));
+    }
+
+    // userId is required to be able to filter channel by current active user
+    if (params.membership && userId) {
+      channels = filterByChannelMembership(channels, params.membership, userId);
+    }
+
+    const sortBy = params.sortBy || 'lastCreated';
+
+    if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+      channels = channels.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+    }
+
+    /*
+     * The server returns channels with empty | null displayName's first before
+     * returning sorted list of channels with displayNames
+     *
+     * This section needs to be updated as displayNames can be null as well
+     */
+    if (sortBy === 'displayName') {
+      channels = channels
+        // 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: channels,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (channel: Amity.Channel, action: Amity.ChannelActionType) => {
+    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([channel.channelId, ...collection.data])];
+      /*
+       * if the filter isDeleted is set, only collection item must be updated and not
+       * the collection
+       */
+    } else if (action === 'onDelete' && !params.isDeleted) {
+      collection.data = collection.data.filter(c => c !== channel.channelId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
+
+    const channels = collection?.data ?? [];
+
+    if (channels.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryChannels, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: channels,
+        };
+
+        if (result) {
+          data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onChannelCreated(channel => realtimeRouter(channel, 'onCreate')),
+    onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')),
+    onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')),
+    onChannelMuted(channel => realtimeRouter(channel, 'onMute')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/observeChannel.ts

@@ -0,0 +1,76 @@
+import { createQuery, runQuery } from '~/core/query/query';
+
+import { getActiveClient } from '~/client/api';
+
+import { getChannel } from '../api';
+
+import {
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMuted,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeChannel } from '@amityco/ts-sdk'
+ *
+ * let channel = {}
+ * const dispose = observeChannel(channelId, ({ data }) => channel = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Channel}
+ *
+ * @param channelId the ID of the channel to observe
+ * @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
+ *
+ * @category Channel Observer
+ */
+export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType, 'onCreate'>]>(
+  channelId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Channel>, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeChannel(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Channel>, action: Events[number]) => {
+    // filter function
+    if (result.data?.channelId !== channelId) return;
+
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
+    onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
+    onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')),
+    onChannelMemberAdded(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
+    ),
+    onChannelMemberRemoved(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberRemoved'),
+    ),
+  );
+
+  runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
+
+  return () => {
+    log(`observeChannel(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};