@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

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

@@ -0,0 +1,55 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  channel1,
+  channelRaw1,
+  client,
+  connectClient,
+  disconnectClient,
+  rawChannelUser,
+  user11,
+} from '~/utils/tests';
+import { onChannelUpdated } from '../onChannelUpdated';
+
+describe('onChannelUpdated event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [rawChannelUser],
+    channels: [channelRaw1],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback when channel have updated', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelUpdated(callback);
+    client.emitter.emit('channel.updated', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel1);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelUpdated(callback);
+    unsub();
+
+    client.emitter.emit('channel.updated', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/observers/index.ts

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

package/src/channel/observers/liveChannel.ts

@@ -0,0 +1,36 @@
+import { liveObject } from '~/utils/liveObject';
+import { onMessageCreated } from '~/message/events';
+import { getChannel } from '../api';
+import { onChannelDeleted, onChannelJoined, onChannelMuted, onChannelUpdated } from '../events';
+
+/**
+ * ```js
+ * import { liveChannel } from '@amityco/ts-sdk';
+ *
+ * let channel;
+ *
+ * const unsubscribe = liveChannel(channelId, response => {
+ *   channel = response.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 Message Live Object
+ */
+export const liveChannel = (
+  channelId: Amity.Channel['channelId'],
+  callback: Amity.LiveObjectCallback<Amity.Channel>,
+): Amity.Unsubscriber => {
+  return liveObject(channelId, callback, 'channelId', getChannel, [
+    onChannelUpdated,
+    onChannelDeleted,
+    onChannelJoined,
+    onChannelMuted,
+    () => onMessageCreated(() => null), // watch unread count
+  ]);
+};

package/src/channel/observers/liveChannelMembers.ts

@@ -0,0 +1,189 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  filterByPropEquality,
+  queryOptions,
+  runQuery,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import {
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberBanned,
+  onChannelMemberRemoved,
+  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
+       */
+      channelMembers = channelMembers.filter(member => {
+        // @ts-ignore
+        if (params.memberships.includes('muted') && member.isMuted) {
+          return true;
+        }
+
+        // @ts-ignore
+        return params.memberships.includes(member.membership);
+      });
+    }
+
+    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 =
+    (action: Amity.ChannelMemberActionType) =>
+    (channel: Amity.Channel, channelMember: Amity.Membership<'channel'>) => {
+      if (params.channelId !== channelMember.channelId) {
+        return;
+      }
+
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) return;
+
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: params.channelId,
+        userId: channelMember.userId,
+      });
+
+      if (channelMember.membership === 'none') {
+        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+      } else if (!collection.data.includes(channelMemberCacheId)) {
+        collection.data = [channelMemberCacheId, ...collection.data];
+      }
+
+      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(
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onChannelMemberBanned(realtimeRouter('onChannelMemberBanned')),
+    onChannelMemberUnbanned(realtimeRouter('onChannelMemberUnbanned')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannelMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/liveChannels.ts

@@ -0,0 +1,200 @@
+/* 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,
+  sortByLastActivity,
+  sortByFirstCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onMessageCreated } from '~/message/events';
+import {
+  onChannelCreated,
+  onChannelDeleted,
+  onChannelUpdated,
+  onChannelMuted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} 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);
+    }
+
+    switch (params.sortBy) {
+      case 'firstCreated':
+        channels = channels.sort(sortByFirstCreated);
+        break;
+
+      case 'lastCreated':
+        channels = channels.sort(sortByLastCreated);
+        break;
+
+      case 'displayName':
+        /*
+         * 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
+         */
+        channels = channels
+          // this needs to be aligned with the backend data type
+          .map(c => (c.displayName ? c : { ...c, displayName: '' }))
+          // @ts-ignore
+          .sort(sortByDisplayName);
+        break;
+
+      default:
+        channels = channels.sort(sortByLastActivity);
+        break;
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: channels,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (_: Amity.ChannelActionType) => (channel: Amity.Channel) => {
+    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
+    if (!collection) return;
+
+    collection.data = [...new Set([channel.channelId, ...collection.data])];
+
+    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(realtimeRouter('onCreate')),
+    onChannelDeleted(realtimeRouter('onDelete')),
+    onChannelUpdated(realtimeRouter('onUpdate')),
+    onChannelMuted(realtimeRouter('onMute')),
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onMessageCreated(() => null), // watch unread count
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/observeChannel.ts

@@ -1,17 +1,18 @@
-import { createQuery, runQuery } from '~/core/query/query'
+import { createQuery, runQuery } from '~/core/query/query';
 
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { getChannel } from '../api'
+import { getChannel } from '../api';
 
 import {
   onChannelUpdated,
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
-  onMemberAdded,
-  onMemberRemoved,
-} from '../events'
+  onChannelMuted,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
 
 /**
  * ```js
@@ -29,52 +30,47 @@ import {
  *
  * @category Channel Observer
  */
-export const observeChannel = <
-  Events extends ['onFetch', 'onUpdate', 'onDelete', 'onJoin', 'onLeft', 'onMemberAdded', 'onMemberRemoved']
->(
+export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType, 'onCreate'>]>(
   channelId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Channel>, Events>
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Channel>, Events>,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeChannel(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeChannel(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (
-    result: Amity.QueryResult<Amity.Channel>,
-    action: Events[number]
-  ) => {
+  const router = (result: Amity.Snapshot<Amity.Channel>, action: Events[number]) => {
     // filter function
-    if (result.data?.channelId !== channelId) return
+    if (result.data?.channelId !== channelId) return;
 
-    if (callback instanceof Function)
-      return callback(result)
+    if (callback instanceof Function) return callback(result);
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    callback[action]?.(result)
-  }
+    callback[action]?.(result);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onChannelUpdated(data => router({ data }, 'onUpdate')),
-    onChannelDeleted(data => router({ data }, 'onDelete')),
-    onChannelJoined(data => router({ data }, 'onJoin')),
-    onChannelLeft(data => router({ data }, 'onLeft')),
-    onMemberAdded(data => router({ data }, 'onMemberAdded')),
-    onMemberRemoved(data => router({ data }, 'onMemberRemoved')),
-  )
+    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'),
-  )
+  runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
 
   return () => {
-    log(`observeChannel(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeChannel(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/observeChannels.ts

@@ -0,0 +1,61 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onChannelCreated,
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMuted,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = observeChannels(channel => merge(channels, channel))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel} for a current user
+ *
+ * @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 Observer
+ */
+export const observeChannels = (
+  callback: Amity.ObjectListener<Amity.Channel, [Exclude<Amity.ChannelActionType, 'onFetch'>]>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeChannels(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (channel: Amity.Channel, action: Exclude<Amity.ChannelActionType, 'onFetch'>) => {
+    if (callback instanceof Function) return callback(channel);
+
+    callback.onEvent?.(action, channel);
+    callback[action]?.(channel);
+  };
+
+  disposers.push(
+    onChannelCreated(data => router(data, 'onCreate')),
+    onChannelUpdated(data => router(data, 'onUpdate')),
+    onChannelDeleted(data => router(data, 'onDelete')),
+    onChannelJoined(data => router(data, 'onJoin')),
+    onChannelLeft(data => router(data, 'onLeft')),
+    onChannelMuted(data => router(data, 'onMute')),
+    onChannelMemberAdded(data => router(data, 'onMemberAdded')),
+    onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
+  );
+
+  return () => {
+    log(`observeChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};