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

package/src/follow/observers/liveFollowers.ts

@@ -0,0 +1,149 @@
+/* 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,
+} from '~/utils/constants';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+import { queryFollowers } from '../api';
+
+/**
+ * ```js
+ * import { liveFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = liveFollowers({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followers for a given userId
+ *
+ * @param userId the 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 messages
+ *
+ * @category Followers Live Collection
+ */
+export const liveFollowers = (
+  params: Amity.FollowerLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveFollowers(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 = ['follow', 'collection', { userId: params.userId, type: 'follower' }];
+
+  const responder = (data: Amity.FollowerLiveCollectionCache) => {
+    let followers: Amity.FollowStatus[] =
+      data.data
+        .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.status) {
+      followers = filterByPropEquality(followers, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.userId !== followStatus.to || !collection) return;
+
+    if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+    } else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+      collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
+
+    const followers = collection?.data ?? [];
+
+    if (followers.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryFollowers, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: followers,
+        };
+
+        if (result) {
+          data.data = [...new Set([...followers, ...result.map(getResolver('follow'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
+    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
+    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
+    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
+    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
+    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
+    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/liveFollowings.ts

@@ -0,0 +1,149 @@
+/* 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,
+} from '~/utils/constants';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+import { queryFollowings } from '../api';
+
+/**
+ * ```js
+ * import { liveFollowings } from '@amityco/ts-sdk'
+ *
+ * let followings = []
+ * const unsub = liveFollowings({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followings, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followings for a given userId
+ *
+ * @param userId the 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 messages
+ *
+ * @category Followings Live Collection
+ */
+export const liveFollowings = (
+  params: Amity.FollowingLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveFollowings(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 = ['follow', 'collection', { userId: params.userId, type: 'following' }];
+
+  const responder = (data: Amity.FollowingLiveCollectionCache) => {
+    let followings: Amity.FollowStatus[] =
+      data.data
+        .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.status) {
+      followings = filterByPropEquality(followings, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followings,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.userId !== followStatus.from || !collection) return;
+
+    if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+    } else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+      collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
+
+    const followings = collection?.data ?? [];
+
+    if (followings.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryFollowings, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: followings,
+        };
+
+        if (result) {
+          data.data = [...new Set([...followings, ...result.map(getResolver('follow'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
+    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
+    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
+    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
+    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
+    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
+    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowings(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

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

package/src/message/observers/tests/liveMessages.test.ts

@@ -0,0 +1,133 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { liveMessages } from '../liveMessages';
+
+import { client, messages } from '~/utils/tests';
+import { queryMessages } from '~/message/api';
+
+describe('liveMessages', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  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 liveMessages check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveMessages({ channelId: messages.channelId }, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return message collection', async () => {
+    const returnValue = [{ messageId: messages.page1[0] }];
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId: messages.channelId }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ channelId: messages.channelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: returnValue,
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should filter deleted messages based on param', async () => {
+    // mock response of queryMessages with a deleted message
+    const returnValue = [
+      { messageId: messages.page1[0], isDeleted: true },
+      { messageId: messages.page1[1], isDeleted: false },
+    ];
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId: messages.channelId, isDeleted: false }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ channelId: messages.channelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [returnValue[1]],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    // mock nextPage()
+  });
+
+  test('it should add new message to collection onCreate', () => {
+    // new message should be added to top of collection
+  });
+
+  test('it should update message in collection onUpdate', () => {
+    // updated message should be reflected in collection
+  });
+
+  test('it should delete message from collection onDelete', () => {
+    // should remove message from collection on delete
+  });
+
+  test('it should get messages from cache if present', () => {
+    // push message with Id in collection response to cache
+    // get request to get that messageId should not be called
+  });
+});

package/src/post/observers/livePosts.ts

@@ -14,6 +14,7 @@ import {
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 
 import {
@@ -57,7 +58,7 @@ export const livePosts = (
   const { log, cache } = getActiveClient();
 
   if (!cache) {
-    console.log('For using Live Collection feature you need to enable Cache!');
+    console.log(ENABLE_CACHE_MESSAGE);
   }
 
   const timestamp = Date.now();

package/src/post/tests/api/getPost.test.ts

@@ -1,12 +1,12 @@
 import { ASCApiError } from '~/core/errors';
-import { client, userPosts } from '~/utils/tests';
+import { client, posts } from '~/utils/tests';
 import { pushToCache, enableCache, disableCache } from '~/cache/api';
 
 import { getPost } from '~/post/api';
 
 describe('post/api', () => {
-  const post = { postId: userPosts.page1[0] };
-  const post2 = { postId: userPosts.page1[1] };
+  const post = { postId: posts.page1[0] };
+  const post2 = { postId: posts.page1[1] };
 
   describe('getPost.locally', () => {
     test('should return undefined if cache is turned off', () => {

package/src/post/tests/api/queryPosts.test.ts

@@ -1,9 +1,9 @@
 import { queryPosts } from '~/post/api';
-import { client, userPosts } from '~/utils/tests';
+import { client, posts } from '~/utils/tests';
 
 describe('post/api', () => {
   test('should return a post query', async () => {
-    const returnValue = [{ postId: userPosts.page1[0] }];
+    const returnValue = [{ postId: posts.page1[0] }];
 
     client.http.get = jest.fn().mockResolvedValue({
       data: {
@@ -13,8 +13,8 @@ describe('post/api', () => {
     });
 
     const data = await queryPosts({
-      targetId: userPosts.targetId,
-      targetType: userPosts.targetType,
+      targetId: posts.targetId,
+      targetType: posts.targetType,
     });
 
     expect(data).toBeDefined();

package/src/utils/constants.ts

@@ -1,2 +1,3 @@
 export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
 export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';
+export const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';