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

package/src/channel/observers/liveChannels.ts

@@ -0,0 +1,178 @@
+/* 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 { onChannelCreated, onChannelDeleted, onChannelUpdated } from '../events';
+import { queryChannels } from '../api';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+
+/**
+ * ```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 } = 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)));
+    }
+
+    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')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/observeChannel.ts

@@ -29,17 +29,7 @@ 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.Snapshot<Amity.Channel>, Events>,
 ): Amity.Unsubscriber => {

package/src/channel/observers/observeChannels.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onChannelCreated,
+  onChannelUpdated,
+  onChannelDeleted,
+  onChannelJoined,
+  onChannelLeft,
+  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')),
+    onChannelMemberAdded(data => router(data, 'onMemberAdded')),
+    onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
+  );
+
+  return () => {
+    log(`observeChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

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

@@ -0,0 +1,173 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import { liveChannels } from '../liveChannels';
+import { queryChannels } from '~/channel/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channel12,
+  channelUser1,
+  channelQueryResponse,
+  channelQueryResponsePage2,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Channel[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+describe('liveChannels', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return channel collection', async () => {
+    // mock response of queryChannels and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels({}, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    const snapshot = getSnapshot();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryChannels()).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.data = channelQueryResponse.data.channels;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  // table for channel filters
+  const filters: [string, Amity.ChannelLiveCollection][] = [
+    ['deleted', { isDeleted: false }],
+    ['tagged', { tags: ['tag2'] }],
+    ['out excluded tags', { excludeTags: ['tag1'] }],
+  ];
+
+  test.each(filters)('it should filter %s channels', async (filter, params) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    const snapshot = getSnapshot();
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryChannels()).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = [channelQueryResponse.data.channels[0]];
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(channelQueryResponse)
+      .mockResolvedValueOnce(channelQueryResponsePage2);
+
+    liveChannels({}, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryChannels()).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await expect(queryChannels()).resolves.toBeTruthy();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [
+      ...channelQueryResponsePage2.data.channels,
+      ...channelQueryResponse.data.channels,
+    ];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events, Amity.Channel][] = [
+    [
+      'it should add new channel to collection onCreate',
+      'v3.channel.didCreate',
+      { ...channel11, channelId: 'new-channel-id' },
+    ],
+    ['it should edit channel in collection onUpdate', 'v3.channel.didUpdate', channel11],
+    ['it should remove channel from collection onDelete', 'v3.channel.didDelete', channel11],
+  ];
+
+  test.each(events)('%s', async (test, event, channel) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    liveChannels({}, callback);
+
+    await expect(queryChannels()).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, {
+      channels: [channel],
+      channelUsers: [channelUser1],
+      users: [],
+      files: [],
+    });
+
+    snapshot.loading = false;
+    // get data based on event
+    switch (event) {
+      case 'v3.channel.didCreate':
+        snapshot.data = [channel, channel11, channel12];
+        break;
+
+      case 'v3.channel.didUpdate':
+        snapshot.data = channelQueryResponse.data.channels;
+        break;
+
+      default:
+        snapshot.data = [channel12];
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/channel/tests/utils/prepareChannelPayload.test.ts

@@ -0,0 +1,120 @@
+import {
+  connectClient,
+  disconnectClient,
+  channel11,
+  channel12,
+  channelRaw1,
+  channelRaw2,
+  channelUser1,
+  channelUser2,
+} from '~/utils/tests';
+
+import { prepareChannelPayload } from '../../utils';
+
+beforeAll(async () => {
+  await connectClient();
+});
+
+afterAll(async () => {
+  await disconnectClient();
+});
+
+const responseSchema = {
+  channels: [],
+  channelUsers: [],
+  files: [],
+  users: [],
+};
+
+const tests = [
+  {
+    id: 1,
+    desc: 'hasMention: false, unreadCount: 0, if channelUsers is empty',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+    },
+  },
+  {
+    id: 2,
+    desc: 'hasMention: false, if channelUser.readToSegment >= channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 3,
+    desc: 'unreadCount: 0, if channelUser.readToSegment = channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw1],
+      channelUsers: [channelUser1],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel11],
+      channelUsers: [channelUser1],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, if channelUser.readToSegment < channelUser.lastMentionedSegment',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 5,
+    desc: 'unreadCount: > 0, if channelUser.readToSegment < channel.messageCount',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+  {
+    id: 4,
+    desc: 'hasMention: true, unreadCount: > 0, if 4 / 5 ',
+    before: {
+      ...responseSchema,
+      channels: [channelRaw2],
+      channelUsers: [channelUser2],
+    },
+    after: {
+      ...responseSchema,
+      channels: [channel12],
+      channelUsers: [channelUser2],
+    },
+  },
+];
+
+describe('channel/utils/prepareChannelPayload', () => {
+  tests.forEach(({ id, desc, before, after }) => {
+    test(`${id} - ${desc}`, () => {
+      expect(prepareChannelPayload(before)).toEqual(after);
+    });
+  });
+});

package/src/channel/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareChannelPayload';

package/src/channel/utils/prepareChannelPayload.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+export const prepareChannelPayload = (
+  payload: Amity.ChannelPayload,
+): Amity.ChannelPayload<any, Amity.Channel> => {
+  const client = getActiveClient();
+
+  const channels: Amity.Channel[] = payload.channels.map(channel => {
+    const channelUser = payload.channelUsers.find(
+      channelUser =>
+        channelUser.userId === client.userId && channel.channelId === channelUser.channelId,
+    )!;
+
+    const hasMention = channelUser
+      ? channelUser.readToSegment < channelUser.lastMentionedSegment
+      : false;
+    const unreadCount =
+      channelUser && channelUser.membership === 'member' && channel.messageCount
+        ? Math.max(0, channel.messageCount - channelUser.readToSegment)
+        : 0;
+
+    return {
+      ...channel,
+      hasMention,
+      unreadCount,
+    };
+  });
+
+  return { ...payload, channels };
+};

package/src/client/api/connectClient.ts

@@ -3,14 +3,14 @@
 import { disconnectClient } from '~/client/api/disconnectClient';
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
+import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
+import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 import { getActiveClient } from './activeClient';
 import { setActiveUser } from './activeUser';
 
 import { getToken } from './getToken';
 import { onClientBanned } from '../events';
-import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
-import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 /**
  * ```js
@@ -33,13 +33,8 @@ import { onUserDeleted } from '~/user/events/onUserDeleted';
  * @async
  */
 export const connectClient = async (
-  params: {
-    userId: Amity.User['userId'];
-    displayName?: Amity.User['displayName'];
-    authToken?: string;
-    deviceId?: Amity.Device['deviceId'];
-  },
-  config?: { disableRTE: boolean },
+  params: Amity.ConnectClientParams,
+  config?: Amity.ConnectClientConfig,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });

package/src/client/api/createClient.ts

@@ -12,6 +12,9 @@ import {
 import { createEventEmitter } from '~/core/events';
 
 import { getActiveClient, setActiveClient } from './activeClient';
+import { getFeedSettings } from './getFeedSettings';
+
+const DEFAULT_DEBUG_SESSION = 'amity';
 
 /**
  * ```js
@@ -23,6 +26,7 @@ import { getActiveClient, setActiveClient } from './activeClient';
  *
  * @param apiKey for the {@link Amity.Client} instance
  * @param apiRegion endpoint to connect to
+ * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
  * @param debugSession session's identifier for the client's logger instance
  * @returns A {@link Amity.Client} instance
  *
@@ -31,7 +35,13 @@ import { getActiveClient, setActiveClient } from './activeClient';
 export const createClient = (
   apiKey: string,
   apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS] = API_REGIONS.SG,
-  debugSession = 'amity',
+  {
+    debugSession = DEFAULT_DEBUG_SESSION,
+    apiEndpoint,
+  }: {
+    debugSession?: string;
+    apiEndpoint?: { http?: string; mqtt?: string };
+  } = {},
 ): Amity.Client => {
   const log = createLogger(debugSession);
 
@@ -40,9 +50,12 @@ export const createClient = (
     apiRegion,
   });
 
-  const http = createHttpTransport(computeUrl('http', apiRegion));
-  const ws = createWebsocketTransport(computeUrl('http', apiRegion));
-  const mqtt = createMqttTransport(computeUrl('mqtt', apiRegion));
+  const httpEndpoint = apiEndpoint?.http ?? computeUrl('http', apiRegion);
+  const mqttEndpoint = apiEndpoint?.mqtt ?? computeUrl('mqtt', apiRegion);
+
+  const http = createHttpTransport(httpEndpoint);
+  const ws = createWebsocketTransport(httpEndpoint);
+  const mqtt = createMqttTransport(mqttEndpoint);
 
   const emitter = createEventEmitter();
 
@@ -56,6 +69,8 @@ export const createClient = (
     mqtt,
     emitter,
     use: () => setActiveClient(client),
+
+    getFeedSettings,
   };
 
   try {

package/src/client/api/getFeedSettings.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { getFeedSettings } from '@amityco/ts-sdk'
+ * const feedSettings = await getFeedSettings()
+ * const postFeedSetting = feedSettings.post
+ * ```
+ *
+ * Fetches a {@link Amity.FeedSettings} object
+ *
+ * @returns A Promise of {@link Amity.FeedSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+export const getFeedSettings = async (): Promise<Amity.FeedSettings> => {
+  const client = getActiveClient();
+
+  const { data } = await client.http.get<Amity.FeedSettingPayload>(
+    `/api/v3/network-settings/feed-setting`,
+  );
+
+  return Object.fromEntries(
+    data.feedSettings.map(({ feedType, contentSettings }) => {
+      return [feedType, contentSettings];
+    }),
+  );
+};