@amityco/ts-sdk 6.29.3-e60fd01.0 → 6.30.0

package/src/userRepository/relationship/follow/observers/getFollowings/FollowingQueryStreamController.ts

@@ -0,0 +1,95 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+import { EnumFollowActions } from '~/userRepository/relationship/follow/enums';
+
+export class FollowingQueryStreamController extends QueryStreamController<
+  Amity.FollowingsPayload,
+  Amity.FollowingLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.FollowingsPayload) => Amity.ProcessedFollowingsPayload;
+
+  constructor(
+    query: Amity.FollowingLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.FollowingsPayload) => Amity.ProcessedFollowingsPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.FollowingsPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.FollowingsPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.follows.map(getResolver('follow')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(this.cacheKey)?.data;
+
+      const follows = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...follows, ...response.follows.map(getResolver('follow'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumFollowActions) {
+    return (followStatus: Amity.InternalFollowStatus) => {
+      const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (this.query.userId !== followStatus.from || !collection) return;
+
+      switch (action) {
+        case EnumFollowActions.OnDeclined:
+        case EnumFollowActions.OnCanceled:
+        case EnumFollowActions.OnUnfollowed:
+        case EnumFollowActions.OnDeleted:
+          collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+          break;
+        case EnumFollowActions.OnRequested:
+        case EnumFollowActions.OnAccepted:
+        case EnumFollowActions.OnFollowed:
+          collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+          break;
+
+        default:
+          break;
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (user: Amity.InternalFollowStatus) => void) => Amity.Unsubscriber;
+      action: EnumFollowActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/userRepository/relationship/follow/observers/getFollowings.ts

@@ -1,24 +1,7 @@
-/* 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 { dropFromCache } from '~/cache/api';
 
-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/queryFollowings';
+import { FollowingLiveCollectionController } from './getFollowings/FollowingLiveCollectionController';
 
 /* begin_public_function
   id: user.relationship.query_my_followings, user.relationship.query_followings
@@ -55,95 +38,12 @@ export const getFollowings = (
   const timestamp = Date.now();
   log(`getFollowings(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 && params.status !== 'all') {
-      followings = filterByPropEquality(followings, 'status', params.status);
-    }
-
-    callback({
-      onNextPage: onFetch,
-      data: followings,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (action: Amity.FollowActionType) => (followStatus: Amity.FollowStatus) => {
-    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 = (initial = false) => {
-    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
-
-    const followings = collection?.data ?? [];
-
-    if (!initial && followings.length > 0 && !collection?.params?.page) return;
-
-    const query = createQuery(queryFollowings, {
-      ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { 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),
-    );
-  };
+  const followingLiveCollection = new FollowingLiveCollectionController(params, callback);
+  const disposers = followingLiveCollection.startSubscription();
 
-  disposers.push(
-    onFollowerRequested(realtimeRouter('onRequested')),
-    onFollowRequestAccepted(realtimeRouter('onAccepted')),
-    onFollowRequestDeclined(realtimeRouter('onDeclined')),
-    onFollowRequestCanceled(realtimeRouter('onCanceled')),
-    onUserFollowed(realtimeRouter('onFollowed')),
-    onUserUnfollowed(realtimeRouter('onUnfollowed')),
-    onFollowerDeleted(realtimeRouter('onDeleted')),
-  );
+  const cacheKey = followingLiveCollection.getCacheKey();
 
-  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`getFollowings(tmpid: ${timestamp}) > dispose`);

package/src/userRepository/relationship/follow/observers/observeFollowers.ts

@@ -8,6 +8,11 @@ import {
   onUserFollowed,
   onUserUnfollowed,
   onFollowerDeleted,
+  onLocalFollowerRequested,
+  onLocalFollowRequestAccepted,
+  onLocalFollowRequestDeclined,
+  onLocalUserFollowed,
+  onLocalUserUnfollowed,
 } from '../events';
 
 /**
@@ -54,6 +59,12 @@ export const observeFollowers = <Events extends Amity.FollowActionType[]>(
     onUserFollowed(x => router(x, 'onFollowed')),
     onUserUnfollowed(x => router(x, 'onUnfollowed')),
     onFollowerDeleted(x => router(x, 'onDeleted')),
+
+    onLocalFollowerRequested(x => router(x, 'onRequested')),
+    onLocalFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onLocalFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onLocalUserFollowed(x => router(x, 'onFollowed')),
+    onLocalUserUnfollowed(x => router(x, 'onUnfollowed')),
   );
 
   return () => {

package/src/userRepository/relationship/follow/observers/observeFollowings.ts

@@ -8,6 +8,11 @@ import {
   onUserFollowed,
   onUserUnfollowed,
   onFollowerDeleted,
+  onLocalFollowerRequested,
+  onLocalFollowRequestAccepted,
+  onLocalFollowRequestDeclined,
+  onLocalUserFollowed,
+  onLocalUserUnfollowed,
 } from '../events';
 
 /**
@@ -54,6 +59,12 @@ export const observeFollowings = <Events extends Amity.FollowActionType[]>(
     onUserFollowed(x => router(x, 'onFollowed')),
     onUserUnfollowed(x => router(x, 'onUnfollowed')),
     onFollowerDeleted(x => router(x, 'onDeleted')),
+
+    onLocalFollowerRequested(x => router(x, 'onRequested')),
+    onLocalFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onLocalFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onLocalUserFollowed(x => router(x, 'onFollowed')),
+    onLocalUserUnfollowed(x => router(x, 'onUnfollowed')),
   );
 
   return () => {

package/src/userRepository/relationship/follow/utils.ts

@@ -0,0 +1,36 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+export function prepareFollowersPayload(
+  response: Amity.FollowersPayload,
+): Amity.ProcessedFollowersPayload {
+  const { users, follows, ...rest } = response;
+
+  return {
+    ...rest,
+    follows,
+    users: users.map(convertRawUserToInternalUser),
+  };
+}
+
+export function prepareFollowingsPayload(
+  response: Amity.FollowersPayload,
+): Amity.ProcessedFollowersPayload {
+  const { users, follows, ...rest } = response;
+
+  return {
+    ...rest,
+    follows,
+    users: users.map(convertRawUserToInternalUser),
+  };
+}
+
+export function prepareFollowStatusPayload(
+  response: Amity.FollowStatusPayload,
+): Amity.ProcessedFollowStatusPayload {
+  const { follows, ...rest } = response;
+
+  return {
+    ...rest,
+    follows,
+  };
+}

package/src/userRepository/utils/convertRawUserToInternalUser.ts

@@ -0,0 +1,6 @@
+export function convertRawUserToInternalUser(rawUser: Amity.RawUser): Amity.InternalUser {
+  return {
+    ...rawUser,
+    isGlobalBanned: rawUser?.isGlobalBan || false,
+  };
+}

package/src/userRepository/utils/prepareBlockedUserPayload.ts

@@ -0,0 +1,19 @@
+import { convertRawUserToInternalUser } from './convertRawUserToInternalUser';
+
+export function prepareBlockedUserPayload(
+  response: Amity.BlockedUserPayload,
+): Amity.ProcessedBlockedUserPayload {
+  const { users, follows, ...rest } = response;
+
+  return {
+    ...rest,
+    follows: follows.map(follow => {
+      const followUser = users.find(user => user.userId === follow.from)!;
+      return {
+        ...follow,
+        user: convertRawUserToInternalUser(followUser),
+      };
+    }),
+    users: users.map(convertRawUserToInternalUser),
+  };
+}

package/src/userRepository/utils/{index.ts → prepareUserPayload.ts}

@@ -1,9 +1,4 @@
-export function convertRawUserToInternalUser(rawUser: Amity.RawUser): Amity.InternalUser {
-  return {
-    ...rawUser,
-    isGlobalBanned: rawUser.isGlobalBan,
-  };
-}
+import { convertRawUserToInternalUser } from './convertRawUserToInternalUser';
 
 export function prepareUserPayload(response: Amity.UserPayload): Amity.ProcessedUserPayload {
   return {

package/src/utils/linkedObject/commentLinkedObject.ts

@@ -1,5 +1,6 @@
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { userLinkedObject } from './userLinkedObject';
+import { isNonNullable } from '~/utils';
 
 export const commentLinkedObject = (comment: Amity.InternalComment): Amity.Comment => {
   return {
@@ -47,23 +48,19 @@ export const commentLinkedObject = (comment: Amity.InternalComment): Amity.Comme
       return undefined;
     },
     get childrenComment(): Amity.Comment[] {
-      return (
-        comment.children
-          .map(childCommentId => {
-            const commentCache = pullFromCache<Amity.InternalComment>([
-              'comment',
-              'get',
-              childCommentId,
-            ]);
+      return comment.children
+        .map(childCommentId => {
+          const commentCache = pullFromCache<Amity.InternalComment>([
+            'comment',
+            'get',
+            childCommentId,
+          ]);
 
-            if (!commentCache?.data) return;
-            return commentCache?.data;
-          })
-          .filter(item => item)
-          // Cannot include this loop in the first loop because
-          // TS always alert returned value is possibly undefined
-          .map(item => commentLinkedObject(item!))
-      );
+          if (!commentCache?.data) return;
+          return commentCache?.data;
+        })
+        .filter(isNonNullable)
+        .map(item => commentLinkedObject(item!));
     },
   };
 };

package/dist/userRepository/utils/index.d.ts

@@ -1,3 +0,0 @@
-export declare function convertRawUserToInternalUser(rawUser: Amity.RawUser): Amity.InternalUser;
-export declare function prepareUserPayload(response: Amity.UserPayload): Amity.ProcessedUserPayload;
-//# sourceMappingURL=index.d.ts.map

package/dist/userRepository/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/userRepository/utils/index.ts"],"names":[],"mappings":"AAAA,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,YAAY,CAKvF;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,oBAAoB,CAK1F"}