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

package/src/core/tests/query/query/runQuery.test.ts

@@ -0,0 +1,182 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { runQuery, createQuery } from '~/core/query';
+import { createPost, getPost } from '~/post/api';
+import { deleteMessage } from '~/message/api';
+
+import { posts, client } from '~/utils/tests';
+
+const createPostArgs: Parameters<typeof createPost> = [
+  {
+    tags: ['a', 'b'],
+    data: {
+      text: 'hello!',
+    },
+    targetType: 'user',
+    targetId: 'userId1',
+  },
+];
+const post = { postId: posts.page1[0] };
+const deletingMsgId = 'deletingId';
+
+describe('Core/Query/runQuery', () => {
+  test('should call query with arguments', () => {
+    const createPostMock = jest.fn().mockResolvedValue('test');
+
+    const query = createQuery(createPostMock, createPostArgs);
+    runQuery(query);
+
+    expect(createPostMock).toBeCalledTimes(1);
+  });
+
+  test('should call callback with cache when valid', () => {
+    enableCache();
+
+    const callback = jest.fn();
+
+    const cachedAt = Date.now();
+    pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toBeCalled();
+    expect(callback).toBeCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt,
+      origin: 'local',
+      loading: false,
+      data: post,
+    });
+
+    disableCache();
+  });
+
+  test('should call callback with server data for invalid cache', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({ data: { posts: [post] } });
+
+    // at the time of writing this test, cache is valid for 2 minutes
+    const expiredDate = Date.parse('04 Dec 1995 00:12:00 GMT');
+    pushToCache(['post', 'get', post.postId], post, { cachedAt: expiredDate });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt: expiredDate,
+      origin: 'local',
+      loading: true,
+      data: post,
+    });
+
+    await expect(getPost(post.postId)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    // checking object containing as expiredAt cannot be predicted :D
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+        data: post,
+      }),
+    );
+
+    disableCache();
+  });
+
+  test('should execute mutators optimistically', () => {
+    enableCache();
+
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn();
+
+    const query = createQuery(createMessage);
+    runQuery(query);
+
+    expect(createMessage.optimistically).toHaveBeenCalled();
+    // should call server right after
+    expect(createMessage).toHaveBeenCalled();
+
+    disableCache();
+  });
+
+  /*
+   * NOTE: del not tested as the args are exactly the same as update
+   *
+   * Tested due to bug where optimistic args was modifying args for del &
+   * update when it does not need to
+   */
+  test('should not change args optimistically for update', () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValue(true);
+    // 'get', gets called after delete to verify delete
+    client.http.get = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query);
+
+    expect(client.http.delete).toHaveBeenCalledWith(`/api/v3/messages/${deletingMsgId}`);
+
+    disableCache();
+  });
+
+  test('should throw error if optimistic execution fails', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn().mockImplementation(() => {
+      throw new Error();
+    });
+
+    const query = createQuery(createMessage);
+    runQuery(query, callback);
+
+    expect(createMessage.optimistically).toThrow();
+    expect(callback).toBeCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    disableCache();
+  });
+
+  test('should return error if call to server fails', async () => {
+    enableCache();
+
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+    const callback = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    await expect(deleteMessage(deletingMsgId)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+      }),
+    );
+
+    disableCache();
+  });
+});

package/src/core/tests/query/query.test.ts

@@ -0,0 +1,19 @@
+import { isFetcher } from '~/core/query';
+
+type isFetcherMockType = jest.Mock<any, any> & {
+  locally?: jest.Mock<any, any>;
+};
+
+describe('Core/Query/Query', () => {
+  const isFetcherMock: isFetcherMockType = jest.fn();
+
+  test('isFetcher without locally', () => {
+    expect(isFetcher(isFetcherMock)).toBe(false);
+  });
+
+  test('isFetcher with locally', () => {
+    isFetcherMock.locally = jest.fn();
+
+    expect(isFetcher(isFetcherMock)).toBe(true);
+  });
+});

package/src/file/api/createVideo.ts

@@ -11,6 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
@@ -19,6 +20,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const createVideo = async (
   formData: FormData,
+  feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
@@ -27,6 +29,10 @@ export const createVideo = async (
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
 
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
   const headers =
     'getHeaders' in formData
       ? (formData as any).getHeaders()

package/src/follow/api/acceptFollower.ts

@@ -28,7 +28,7 @@ export const acceptFollower = async (userId: Amity.User['userId']): Promise<bool
     ingestInCache(data);
   }
 
-  fireEvent('follow.accepted', data.follows[0]);
+  fireEvent('follow.accepted', data);
 
   return true;
 };

package/src/follow/api/declineFollower.ts

@@ -28,7 +28,7 @@ export const declineFollower = async (userId: Amity.User['userId']): Promise<boo
     ingestInCache(data);
   }
 
-  fireEvent('follow.requestDeclined', data.follows[0]);
+  fireEvent('follow.requestDeclined', data);
 
   return true;
 };

package/src/follow/api/follow.ts

@@ -32,10 +32,7 @@ export const follow = async (
     ingestInCache(data, { cachedAt });
   }
 
-  fireEvent(
-    data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested',
-    data.follows[0],
-  );
+  fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
 
   return {
     data: data.follows[0],

package/src/follow/api/getFollowInfo.ts

@@ -27,15 +27,18 @@ export const getFollowInfo = async (
   const client = getActiveClient();
   client.log('follow/getFollowInfo', userId);
 
-  const { data } = await client.http.get<Amity.FollowInfoPayload>(
+  const { data } = await client.http.get<Amity.FollowInfoMePayload | Amity.FollowInfoPayload>(
     client.userId === userId ? `/api/v4/me/followInfo` : `/api/v4/users/${userId}/followInfo`,
   );
 
   const cachedAt = client.cache && Date.now();
-  const followInfo = {
-    ...data.followCounts[0],
-    status: data.follows?.[0]?.status,
-  };
+  const followInfo =
+    'follows' in data
+      ? {
+          ...data.followCounts[0],
+          status: data.follows?.[0]?.status,
+        }
+      : data.followCounts[0];
 
   if (client.cache) {
     pushToCache(getCacheKey(userId), followInfo, { cachedAt });

package/src/follow/api/queryFollowers.ts

@@ -14,11 +14,10 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowers = async (query: {
-  userId: Amity.User['userId'];
-  status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => queryFollows('followers', query);
+export const queryFollowers = async (
+  query: Amity.QueryFollowers,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('followers', query);
 
 /**
  * ```js
@@ -35,5 +34,5 @@ export const queryFollowers = async (query: {
  */
 queryFollowers.locally = (
   query: Parameters<typeof queryFollowers>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('followers', query);

package/src/follow/api/queryFollowings.ts

@@ -14,11 +14,10 @@ import { queryFollows } from './utils';
  * @category Follow API
  * @async
  */
-export const queryFollowings = async (query: {
-  userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatus['status'], 'none'>;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => queryFollows('following', query);
+export const queryFollowings = async (
+  query: Amity.QueryFollowings,
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('following', query);
 
 /**
  * ```js
@@ -35,5 +34,5 @@ export const queryFollowings = async (query: {
  */
 queryFollowings.locally = (
   query: Parameters<typeof queryFollowings>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('following', query);

package/src/follow/api/unfollow.ts

@@ -28,7 +28,7 @@ export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> =
     ingestInCache(data);
   }
 
-  fireEvent('follow.unfollowed', data.follows[0]);
+  fireEvent('follow.unfollowed', data);
 
   return true;
 };

package/src/follow/api/utils.ts

@@ -1,5 +1,5 @@
 import { getActiveClient } from '~/client/api';
-import { toPage, toToken } from '~/core/query';
+import { toPageRaw, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
@@ -8,10 +8,10 @@ export const queryFollows = async (
   key: 'followers' | 'following',
   query: {
     userId: Amity.User['userId'];
-    status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>;
-    page?: Amity.Page;
+    status?: Exclude<Amity.FollowStatusType, 'none'>;
+    page?: Amity.PageRaw;
   },
-): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> => {
   const client = getActiveClient();
   client.log(`follow/queryF${key.substring(1)}`, query);
 
@@ -22,7 +22,7 @@ export const queryFollows = async (
     {
       params: {
         ...params,
-        token: toToken(page, 'skiplimit'),
+        token: toToken(page, 'afterbeforeraw'),
       },
     },
   );
@@ -36,15 +36,15 @@ export const queryFollows = async (
     ingestInCache(payload as Amity.FollowersPayload, { cachedAt });
 
     const cacheKey = [
-      key,
+      'follow',
       'query',
-      { ...params, userId, options: { ...page } } as Amity.Serializable,
+      { ...params, userId, options: { ...page }, type: key } as Amity.Serializable,
     ];
     pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: follows, cachedAt, prevPage, nextPage };
 };
@@ -52,7 +52,7 @@ export const queryFollows = async (
 queryFollows.locally = (
   key: Parameters<typeof queryFollows>[0],
   query: Parameters<typeof queryFollows>[1],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined => {
   const client = getActiveClient();
   client.log(`follow/queryF${key.substring(1)}.locally`, query);
 
@@ -60,7 +60,11 @@ queryFollows.locally = (
 
   const { page, ...params } = query;
 
-  const queryKey = [key, 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = [
+    'follow',
+    'query',
+    { ...params, options: { ...page }, type: key } as Amity.Serializable,
+  ];
   const { data, cachedAt } =
     pullFromCache<{ follows: string[] } & Amity.Pagination>(queryKey) ?? {};
 
@@ -73,8 +77,8 @@ queryFollows.locally = (
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
 
   return follows.length === data?.follows?.length
     ? { data: follows, cachedAt, prevPage, nextPage }

package/src/follow/events/utils.ts

@@ -9,11 +9,11 @@ export const createFollowEventSubscriber = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.FollowStatus) => {
+  const filter = (payload: Amity.FollowersPayload | Amity.FollowStatusPayload) => {
     if (!client.cache) {
-      callback(payload);
+      callback(payload.follows[0]);
     } else {
-      ingestInCache({ follows: [payload] });
+      ingestInCache(payload);
 
       const queries = [
         ...(queryCache(['followers', 'query']) ?? []),
@@ -21,11 +21,14 @@ export const createFollowEventSubscriber = (
       ];
 
       queries
-        // @ts-ignore
-        .filter(({ key }) => key[2].userId === payload.from || key[2].userId === payload.to)
+        .filter(
+          ({ key }) =>
+            // @ts-ignore
+            key[2].userId === payload.follows[0].from || key[2].userId === payload.follows[0].to,
+        )
         .forEach(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
 
-      callback(payload);
+      callback(payload.follows[0]);
     }
   };
 

package/src/follow/observers/index.ts

@@ -1,3 +1,6 @@
 export * from './observeFollowInfo';
 export * from './observeFollowers';
 export * from './observeFollowings';
+
+export * from './liveFollowers';
+export * from './liveFollowings';

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 && params.status !== 'all') {
+      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());
+  };
+};