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

package/src/follow/tests/observers/liveFollowings.test.ts

@@ -0,0 +1,239 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { queryFollowings } from '../../api/queryFollowings';
+import { liveFollowings } from '../../observers/liveFollowings';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow11,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('liveFollowings', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { userId } = follows;
+  const args: Amity.FollowingLiveCollection = { userId };
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is diabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+
+    const callback = jest.fn();
+    jest.spyOn(global.console, 'log');
+    client.http.get = jest.fn();
+
+    // call liveFollowings check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveFollowings(args, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return following collection', async () => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page1 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = response.data.follows;
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return error on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowings(args)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const statusFilters: [string, Amity.FollowingLiveCollection][] = [
+    ['all', { ...args, status: 'all', limit: 10 }],
+    ['accepted', { ...args, status: 'accepted', limit: 10 }],
+    ['pending', { ...args, status: 'pending', limit: 10 }],
+  ];
+
+  test.each(statusFilters)('it should filter %s follows based on param', async (filter, params) => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page1 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    // TODO : why ts gives no shit about args here ? wrong type :D
+    const query = queryFollowings(params);
+
+    await expect(query).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data =
+      filter === 'all'
+        ? response.data.follows
+        : response.data.follows.filter(fl => fl.status === filter);
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const snapshot = getSnapshot();
+    const args: Amity.FollowingLiveCollection = { userId, limit: 3 };
+    const next = encodeJson({
+      limit: 3,
+      before: follows.page1[2].from,
+      updatedAt: follows.page1[2].updatedAt,
+    });
+
+    const response = { data: { follows: follows.page2, paging: {} } };
+    const responseWithNextPage = { data: { follows: follows.page1, paging: { next } } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(responseWithNextPage);
+
+    liveFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    onNextPage();
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    snapshot.loading = false;
+    snapshot.data = [...responseWithNextPage.data.follows, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const createEvents: [keyof Amity.Events][] = [
+    ['follow.created'],
+    ['follow.requested'],
+    ['follow.accepted'],
+  ];
+
+  test.each(createEvents)('it should add new follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const newFollowing: Amity.FollowStatus = {
+      ...follow11,
+      to: 'some-user',
+    };
+    const response = { data: { follows: follows.page1, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(args, callback);
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [newFollowing] });
+
+    snapshot.loading = false;
+    snapshot.data = [newFollowing, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const removeEvents: [keyof Amity.Events][] = [
+    ['follow.requestDeclined'],
+    ['follow.requestCanceled'],
+    ['follow.unfollowed'],
+    ['follow.followerDeleted'],
+  ];
+
+  test.each(removeEvents)('it should remove a follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const response = { data: { follows: follows.page1, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(args, callback);
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [response.data.follows[0]] });
+
+    const [first, ...data] = response.data.follows;
+
+    snapshot.data = data;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/index.ts

@@ -1,5 +1,5 @@
 // types
-import './@types';
+export * from './@types';
 
 export * from './version';
 

package/src/message/api/queryMessages.ts

@@ -19,16 +19,9 @@ import { getResolver } from '~/core/model';
  * @category Message API
  * @async
  */
-export const queryMessages = async (query: {
-  channelId: Amity.Channel['channelId'];
-  type?: Amity.MessageContentType;
-  parentId?: Amity.Message['parentId'];
-  filterByParentId?: boolean;
-  isDeleted?: boolean;
-  tags?: Amity.Taggable['tags'];
-  excludeTags?: Amity.Taggable['tags'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
+export const queryMessages = async (
+  query: Amity.QueryMessages,
+): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 

package/src/message/observers/index.ts

@@ -1,2 +1,3 @@
 export { observeMessage } from './observeMessage';
 export { observeMessages } from './observeMessages';
+export { liveMessages } from './liveMessages';

package/src/message/observers/liveMessages.ts

@@ -0,0 +1,141 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions, filterByPropEquality } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+
+import { onMessageCreated, onMessageDeleted, onMessageUpdated } from '../events';
+import { queryMessages } from '../api';
+
+/**
+ * ```js
+ * import { liveMessages } from '@amityco/ts-sdk'
+ *
+ * let messages = []
+ * const unsub = liveMessages({
+ *   channelId: Amity.Channel['channelId'];
+ * }, response => merge(messages, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Message} for a given target object
+ *
+ * @param params for querying memssages from a channel
+ * @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 messages
+ *
+ * @category Messages Live Collection
+ */
+export const liveMessages = (
+  params: Amity.MessagesLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Message>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveMessages(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 = ['message', 'collection', { channelId: params.channelId }];
+
+  const responder = (data: Amity.MessageLiveCollectionCache) => {
+    let messages: Amity.Message[] =
+      data.data
+        .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    /*
+     * for cases when message is deleted via RTE, this flag is used to get
+     * items fro cache that are deleted | !deleted
+     */
+    messages = filterByPropEquality(messages, 'isDeleted', params.isDeleted);
+
+    callback({
+      onNextPage: onFetch,
+      data: messages,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (message: Amity.Message, action: Amity.MessageActionType) => {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.channelId !== message.channelId || !collection) return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([message.messageId, ...collection.data])];
+    } else if (['onDelete'].includes(action)) {
+      collection.data = collection.data.filter(m => m !== message.messageId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
+
+    const messages = collection?.data ?? [];
+
+    if (messages.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryMessages, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: messages,
+        };
+
+        if (result) {
+          data.data = [...new Set([...messages, ...result.map(getResolver('message'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onMessageCreated(message => realtimeRouter(message, 'onCreate')),
+    onMessageDeleted(message => realtimeRouter(message, 'onDelete')),
+
+    onMessageUpdated(message => realtimeRouter(message, 'onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/message/observers/observeMessages.ts

@@ -12,7 +12,6 @@ import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '../events'
  *
  * Observe all mutations on a list of {@link Amity.Message} for a given {@link Amity.Channel} object
  *
- * @param client the client to observe the message with
  * @param channelId the ID of the channel where to observe the messages
  * @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 messages