@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/subChannel/observers/liveSubChannels.ts

@@ -0,0 +1,137 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastActivity,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onSubChannelFetched } from '~/subChannel/events/onSubChannelFetched';
+import { isCollectionOutdated, merge } from '~/utils';
+import { onSubChannelCreated, onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { querySubChannels } from '../api';
+
+/**
+ * ```js
+ * import { liveSubChannels } from '@amityco/ts-sdk';
+ *
+ * let subChannels = [];
+ *
+ * const unsubscribe = liveSubChannels({ channelId }, response => {
+ *   merge(subChannels, response.data);
+ * });
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.SubChannel}s
+ *
+ * @param params for querying sub 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 sub channels
+ *
+ * @category SubChannel Live Collection
+ */
+export const liveSubChannels = (
+  params: Amity.SubChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.SubChannel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+  const timestamp = Date.now();
+  log(`liveSubChannels(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...queryParams } = params;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  let snapshot: Amity.SubChannelLiveCollectionCache;
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const responder = (data: Amity.SubChannelLiveCollectionCache) => {
+    let subChannels: Amity.SubChannel[] = data.data;
+
+    if (params.includeDeleted === false) {
+      subChannels = filterByPropEquality(subChannels, 'isDeleted', false);
+    }
+
+    subChannels.sort(sortByLastActivity);
+
+    callback({
+      onNextPage: onFetch,
+      data: subChannels,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.ChannelActionType) => (subChannel: Amity.SubChannel) => {
+    if (
+      params.channelId !== subChannel.channelId ||
+      !snapshot ||
+      !isCollectionOutdated(snapshot.data, subChannel, action)
+    ) {
+      return;
+    }
+
+    if (action === 'onCreate') {
+      snapshot.data = [subChannel, ...snapshot.data];
+    } else {
+      snapshot.data = snapshot.data.map(x =>
+        x.subChannelId === subChannel.subChannelId ? subChannel : x,
+      );
+    }
+
+    responder(snapshot);
+  };
+
+  const onFetch = () => {
+    const subChannels = snapshot ? snapshot.data : [];
+
+    if (subChannels.length > 0 && !snapshot?.params.page) {
+      return;
+    }
+
+    const query = createQuery(querySubChannels, {
+      ...queryParams,
+      page: snapshot?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        snapshot = {
+          loading,
+          error,
+          params: { page },
+          data: result ? merge(subChannels, result) : subChannels,
+        };
+
+        responder(snapshot);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onSubChannelCreated(realtimeRouter('onCreate')),
+    onSubChannelDeleted(realtimeRouter('onDelete')),
+    onSubChannelFetched(realtimeRouter('onFetch')),
+    onSubChannelUpdated(realtimeRouter('onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveSubChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannel/observers/tests/liveSubChannel.test.ts

@@ -0,0 +1,130 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { createQuery, runQuery } from '~/core/query';
+import { deleteSubChannel, getSubChannel, updateSubChannel } from '~/subChannel/api';
+import { getFutureDate } from '~/core/model';
+import { liveSubChannel } from '../liveSubChannel';
+import { convertFromRaw } from '../../utils';
+
+describe('liveSubChannel', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const subChannel = convertFromRaw(rawSubChannel);
+  const response = { data: { messageFeeds: [rawSubChannel] } };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.Events][] = [
+    ['should get update on message-feed.updated event', 'message-feed.updated'],
+    ['should get update on message-feed.deleted event', 'message-feed.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...rawSubChannel,
+      name: event,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit(event, { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: convertFromRaw(update),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('should get an update without rte subscription', () => {
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    test('if getSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest
+        .fn()
+        .mockResolvedValueOnce(response)
+        .mockResolvedValueOnce({ data: { messageFeeds: [update] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await getSubChannel(subChannel.subChannelId);
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if updateSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.put = jest.fn().mockResolvedValue({ data: { messageFeeds: [update] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await updateSubChannel(subChannel.subChannelId, { displayName: update.name });
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if deleteSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.delete = jest.fn().mockResolvedValue({ data: { success: true } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      runQuery(createQuery(deleteSubChannel, subChannel.subChannelId));
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: { ...subChannel, isDeleted: true, updatedAt: expect.anything() },
+          loading: false,
+        }),
+      );
+    });
+  });
+});

package/src/subChannel/observers/tests/liveSubChannels.test.ts

@@ -0,0 +1,209 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { convertFromRaw } from '~/subChannel/utils';
+import { getFutureDate, getPastDate } from '~/core/model';
+import { liveSubChannels } from '../liveSubChannels';
+
+describe('liveSubChannels', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const response = {
+    data: {
+      messageFeeds: [rawSubChannel],
+      paging: {},
+    },
+  };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should get sub channels', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        loading: true,
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertFromRaw(rawSubChannel)],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should filter deleted sub channels based on params', async () => {
+    const rawSubChannels = [
+      generateRawSubChannel({ isDeleted: true }),
+      generateRawSubChannel({ messageFeedId: 'sub-channel-id-2' }),
+    ];
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: rawSubChannels,
+        paging: {},
+      },
+    });
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId, includeDeleted: false }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertFromRaw(rawSubChannels[1])],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should fetch next page', async () => {
+    const rawSubChannel2 = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getPastDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel2],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+    callback.mock.lastCall[0].onNextPage();
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        hasNextPage: true,
+        onNextPage: expect.anything(),
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        data: [rawSubChannel, rawSubChannel2].map(convertFromRaw),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('events', () => {
+    const newRawSubChannel = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getFutureDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const updatedRawSubChannel = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const deletedRawSubChannel = {
+      ...rawSubChannel,
+      isDeleted: true,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.RawSubChannel, Amity.SubChannel[]][] = [
+      [
+        'should add new sub channel to collection onCreate',
+        'message-feed.created',
+        newRawSubChannel,
+        [newRawSubChannel, rawSubChannel].map(convertFromRaw),
+      ],
+      [
+        'should remove sub channel from collection onDelete',
+        'message-feed.deleted',
+        deletedRawSubChannel,
+        [],
+      ],
+      [
+        'should update sub channel in collection onUpdate',
+        'message-feed.updated',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(convertFromRaw),
+      ],
+      [
+        'should update sub channel in collection onFetch',
+        'local.message-feed.fetched',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(convertFromRaw),
+      ],
+    ];
+
+    type testHandlerType = (...args: typeof cases[number]) => Promise<void>;
+    const testHandler: testHandlerType = async (test, event, rawEventSubChannel, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+
+      liveSubChannels(
+        { channelId: rawSubChannel.channelPublicId, includeDeleted: false },
+        callback,
+      );
+      await pause();
+      if (event === 'local.message-feed.fetched') {
+        pushToCache(
+          ['subChannel', 'get', rawEventSubChannel.messageFeedId],
+          convertFromRaw(rawEventSubChannel),
+        );
+        client.emitter.emit(event, { messageFeeds: [convertFromRaw(rawEventSubChannel)] });
+      } else {
+        client.emitter.emit(event, { messageFeeds: [rawEventSubChannel] });
+      }
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: expected,
+          loading: false,
+        }),
+      );
+    };
+
+    test.each(cases)('%s', testHandler);
+  });
+});

package/src/subChannel/utils/index.ts

@@ -0,0 +1,50 @@
+export function convertFromRaw({
+  channelId,
+  channelPublicId,
+  channelType,
+  childCount,
+  creatorId,
+  creatorPublicId,
+  lastMessageId,
+  lastMessageTimestamp,
+  messageFeedId,
+  name,
+  ...rest
+}: Amity.RawSubChannel): Amity.SubChannel {
+  return {
+    ...rest,
+    channelId: channelPublicId,
+    creatorId: creatorPublicId,
+    displayName: name,
+    lastActivity: lastMessageTimestamp,
+    latestMessageId: lastMessageId,
+    messageCount: childCount,
+    subChannelId: messageFeedId,
+  };
+}
+
+export const prepareSubChannelPayload = (
+  payload: Amity.SubChannelPayload,
+): Amity.ProcessedSubChannelPayload => {
+  return {
+    ...payload,
+    messageFeeds: payload.messageFeeds.map(convertFromRaw),
+  };
+};
+
+type RawQuerySubChannels = Omit<Amity.QuerySubChannels, 'excludeDefaultSubChannel'> & {
+  excludeDefaultMessageFeed?: Amity.QuerySubChannels['excludeDefaultSubChannel'];
+};
+
+export function convertQueryParams({
+  excludeDefaultSubChannel,
+  ...rest
+}: Amity.QuerySubChannels): RawQuerySubChannels {
+  const out: RawQuerySubChannels = { ...rest };
+
+  if (excludeDefaultSubChannel !== undefined) {
+    out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+  }
+
+  return out;
+}

package/src/user/api/getUser.ts

@@ -2,7 +2,15 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+/* begin_public_function
+  id: user.get
+*/
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
@@ -17,25 +25,48 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category User API
  * @async
  */
-export const getUser = async (userId: Amity.User['userId']): Promise<Amity.Cached<Amity.User>> => {
+export const getUser = async (
+  userId: Amity.User['userId'],
+  isLive = false,
+): Promise<Amity.Cached<Amity.User>> => {
   const client = getActiveClient();
   client.log('user/getUser', userId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.UserPayload>(
-    `/api/v3/users/${encodeURIComponent(userId)}`,
-  );
+  if (!isLive) {
+    console.log('getUser will be deprecated on 25th November 2022, please use liveUser instead.');
+  }
+
+  isInTombstone('user', userId);
+
+  let data: Amity.UserPayload;
+
+  try {
+    const response = await client.http.get<Amity.UserPayload>(
+      `/api/v3/users/${encodeURIComponent(userId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('user', userId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { users } = data;
 
+  fireEvent('user.fetched', data);
+
   return {
     data: users.find(user => user.userId === userId)!,
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/user/api/getUsers.ts

@@ -2,7 +2,11 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: user.get_by_ids
+*/
 /**
  * ```js
  * import { getUsers } from '@amityco/ts-sdk'
@@ -33,6 +37,8 @@ export const getUsers = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  fireEvent('user.fetched', data);
+
   return {
     data: data.users,
     cachedAt,

package/src/user/api/queryUsers.ts

@@ -5,7 +5,11 @@ import { toPage, toToken } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+import { fireEvent } from '~/core/events';
 
+/* begin_public_function
+  id: user.query, user.search
+*/
 /**
  * ```js
  * import { queryUsers } from '@amityco/ts-sdk'
@@ -22,19 +26,19 @@ import { getResolver } from '~/core/model';
  * @async
  */
 export const queryUsers = async (
-  query: {
-    displayName?: Amity.User['displayName'];
-    filter?: 'all' | 'flagged';
-    sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-    page?: Amity.Page;
-  } = {},
+  query: Amity.QueryUsers = {},
 ): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
   const client = getActiveClient();
   client.log('user/queryUsers', query);
 
-  const { page, displayName, filter = 'all', sortBy = 'displayName', ...params } = query;
+  const {
+    page = { limit: 10 },
+    displayName,
+    filter = 'all',
+    sortBy = 'displayName',
+    ...params
+  } = query;
 
-  // API-FIX: parameters should be querystring.
   const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(`/api/v3/users`, {
     params: {
       ...params,
@@ -56,15 +60,22 @@ export const queryUsers = async (
   if (client.cache) {
     ingestInCache(payload as Amity.UserPayload, { cachedAt });
 
-    const cacheKey = ['user', 'query', query as Amity.Serializable];
+    /*
+     * using query as cache key over params because if the keyword, filter, sort
+     * change the API will NOT cache results, when it should
+     */
+    const cacheKey = ['user', 'query', { ...query, options: { ...page } } as Amity.Serializable];
     pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
   }
 
+  fireEvent('user.fetched', data);
+
   const prevPage = toPage(paging.previous);
   const nextPage = toPage(paging.next);
 
   return { data: users, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -88,9 +99,19 @@ queryUsers.locally = (
 
   if (!client.cache) return;
 
-  const queryKey = ['user', 'query', query as Amity.Serializable];
+  const { page = { limit: 10 } } = query ?? {};
+
+  const cacheKey = [
+    'user',
+    'query',
+    {
+      ...query,
+      options: { ...page },
+    } as Amity.Serializable,
+  ];
+
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(queryKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(cacheKey) ?? {};
 
   const users: Amity.User[] =
     data?.users