@amityco/ts-sdk-react-native 6.29.3-669217e.0 → 6.29.3-fe4e045.0

package/src/userRepository/relationship/follow/events/onFollowerUserDeleted.ts

@@ -0,0 +1,33 @@
+import { pullFromCache, queryCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+import { createEventSubscriber } from '~/core/events';
+import { getResolver } from '~/core/model';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+
+export const onFollowerUserDeleted =
+  ({ userId }: { userId: string }) =>
+  (callback: Amity.Listener<Amity.InternalFollowStatus>) => {
+    const client = getActiveClient();
+
+    const filter = (data: Amity.UserPayload) => {
+      const userPayload = prepareUserPayload(data);
+
+      ingestInCache(userPayload);
+
+      const cacheData = pullFromCache<Amity.InternalFollowStatus>([
+        'follow',
+        'get',
+        getResolver('follow')({
+          from: userPayload.users[0].userId,
+          to: userId,
+        }),
+      ]);
+
+      if (!cacheData) return;
+
+      callback(cacheData?.data);
+    };
+
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+  };

package/src/userRepository/relationship/follow/events/onFollowingUserDeleted.ts

@@ -0,0 +1,33 @@
+import { pullFromCache, queryCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+import { createEventSubscriber } from '~/core/events';
+import { getResolver } from '~/core/model';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+
+export const onFollowingUserDeleted =
+  ({ userId }: { userId: string }) =>
+  (callback: Amity.Listener<Amity.InternalFollowStatus>) => {
+    const client = getActiveClient();
+
+    const filter = (data: Amity.UserPayload) => {
+      const userPayload = prepareUserPayload(data);
+
+      ingestInCache(userPayload);
+
+      const cacheData = pullFromCache<Amity.InternalFollowStatus>([
+        'follow',
+        'get',
+        getResolver('follow')({
+          from: userId,
+          to: userPayload.users[0].userId,
+        }),
+      ]);
+
+      if (!cacheData) return;
+
+      callback(cacheData?.data);
+    };
+
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+  };

package/src/userRepository/relationship/follow/events/onLocalFollowRequestAccepted.ts

@@ -0,0 +1,5 @@
+import { createLocalFollowEventSubscriber } from './utils';
+
+export const onLocalFollowRequestAccepted = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createLocalFollowEventSubscriber('local.follow.accepted', callback);

package/src/userRepository/relationship/follow/events/onLocalFollowRequestDeclined.ts

@@ -0,0 +1,5 @@
+import { createLocalFollowEventSubscriber } from './utils';
+
+export const onLocalFollowRequestDeclined = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createLocalFollowEventSubscriber('local.follow.requestDeclined', callback);

package/src/userRepository/relationship/follow/events/onLocalFollowerRequested.ts

@@ -0,0 +1,5 @@
+import { createLocalFollowEventSubscriber } from './utils';
+
+export const onLocalFollowerRequested = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createLocalFollowEventSubscriber('local.follow.requested', callback);

package/src/userRepository/relationship/follow/events/onLocalUserFollowed.ts

@@ -0,0 +1,5 @@
+import { createLocalFollowEventSubscriber } from './utils';
+
+export const onLocalUserFollowed = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createLocalFollowEventSubscriber('local.follow.created', callback);

package/src/userRepository/relationship/follow/events/onLocalUserUnfollowed.ts

@@ -0,0 +1,5 @@
+import { createLocalFollowEventSubscriber } from './utils';
+
+export const onLocalUserUnfollowed = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createLocalFollowEventSubscriber('local.follow.unfollowed', callback);

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

@@ -2,31 +2,42 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber } from '~/core/events';
 import { queryCache, upsertInCache } from '~/cache/api';
+import { prepareFollowersPayload, prepareFollowStatusPayload } from '../utils';
 
 export const createFollowEventSubscriber = (
   event: keyof Amity.MqttFollowEvents,
-  callback: Amity.Listener<Amity.FollowStatus>,
+  callback: Amity.Listener<Amity.InternalFollowStatus>,
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.FollowersPayload | Amity.FollowStatusPayload) => {
+  const filter = (data: Amity.FollowersPayload) => {
+    const payload = prepareFollowersPayload(data);
+
     if (!client.cache) {
       callback(payload.follows[0]);
     } else {
       ingestInCache(payload);
 
-      const queries = [
-        ...(queryCache(['followers', 'query']) ?? []),
-        ...(queryCache(['followings', 'query']) ?? []),
-      ];
-
-      queries
-        .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.follows[0]);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};
+
+export const createLocalFollowEventSubscriber = (
+  event: keyof Amity.LocalFollowEvents,
+  callback: Amity.Listener<Amity.InternalFollowStatus>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (data: Amity.FollowStatusPayload) => {
+    const payload = prepareFollowStatusPayload(data);
+
+    if (!client.cache) {
+      callback(payload.follows[0]);
+    } else {
+      ingestInCache(payload);
 
       callback(payload.follows[0]);
     }

package/src/userRepository/relationship/follow/observers/getFollowers/FollowerLiveCollectionController.ts

@@ -0,0 +1,132 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { FollowerPaginationController } from './FollowerPaginationController';
+import { FollowerQueryStreamController } from './FollowerQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { EnumFollowActions } from '~/userRepository/relationship/follow/enums';
+import { isNonNullable } from '~/utils';
+import {
+  onFollowerDeleted,
+  onFollowRequestAccepted,
+  onFollowRequestCanceled,
+  onFollowRequestDeclined,
+  onLocalFollowRequestAccepted,
+  onLocalFollowRequestDeclined,
+  onLocalUserFollowed,
+  onLocalUserUnfollowed,
+  onUserFollowed,
+  onUserUnfollowed,
+} from '../../events';
+import { prepareFollowersPayload } from '../../utils';
+import { onFollowerUserDeleted } from '../../events/onFollowerUserDeleted';
+
+export class FollowerLiveCollectionController extends LiveCollectionController<
+  'follower',
+  Amity.FollowerLiveCollection,
+  Amity.FollowStatus,
+  FollowerPaginationController
+> {
+  private queryStreamController: FollowerQueryStreamController;
+
+  private query: Amity.FollowerLiveCollection;
+
+  constructor(
+    query: Amity.FollowerLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['follow', 'collection', queryStreamId];
+    const paginationController = new FollowerPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new FollowerQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareFollowersPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.FollowersPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'follower'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onUserFollowed, action: EnumFollowActions.OnFollowed },
+      { fn: onUserUnfollowed, action: EnumFollowActions.OnUnfollowed },
+      { fn: onFollowRequestAccepted, action: EnumFollowActions.OnAccepted },
+      { fn: onFollowRequestDeclined, action: EnumFollowActions.OnDeclined },
+      { fn: onFollowRequestCanceled, action: EnumFollowActions.OnCanceled },
+      { fn: onFollowerDeleted, action: EnumFollowActions.OnDeleted },
+      { fn: onLocalFollowRequestAccepted, action: EnumFollowActions.OnAccepted },
+      { fn: onLocalFollowRequestDeclined, action: EnumFollowActions.OnDeclined },
+      { fn: onLocalUserFollowed, action: EnumFollowActions.OnFollowed },
+      { fn: onLocalUserUnfollowed, action: EnumFollowActions.OnUnfollowed },
+      {
+        fn: onFollowerUserDeleted({ userId: this.query.userId }),
+        action: EnumFollowActions.OnUserDeleted,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalFollowStatus>(['follow', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.InternalFollowStatus[]) {
+    let followers = data;
+
+    if (this.query.status && this.query.status !== Amity.FollowStatusTypeEnum.All) {
+      followers = followers.filter(follower => follower.status === this.query.status);
+    }
+
+    followers = followers.filter(follower => {
+      const fromUser = pullFromCache<Amity.InternalUser>(['user', 'get', follower.from])?.data;
+      return fromUser?.isDeleted == null || fromUser?.isDeleted === false;
+    });
+
+    return followers;
+  }
+}

package/src/userRepository/relationship/follow/observers/getFollowers/FollowerPaginationController.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class FollowerPaginationController extends PaginationController<
+  'follower',
+  Amity.FollowerLiveCollection
+> {
+  async getRequest(queryParams: Amity.FollowerLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, userId, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+    const client = getActiveClient();
+
+    const path =
+      client.userId === userId ? `/api/v4/me/followers` : `/api/v4/users/${userId}/followers`;
+
+    const { data: queryResponse } = await this.http.get<Amity.FollowersPayload & Amity.Pagination>(
+      path,
+      {
+        params: {
+          ...params,
+          options,
+          isDeleted: false,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/userRepository/relationship/follow/observers/getFollowers/FollowerQueryStreamController.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 FollowerQueryStreamController extends QueryStreamController<
+  Amity.FollowersPayload,
+  Amity.FollowerLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.FollowersPayload) => Amity.ProcessedFollowersPayload;
+
+  constructor(
+    query: Amity.FollowerLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.FollowersPayload) => Amity.ProcessedFollowersPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.FollowersPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.FollowersPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.follows.map(getResolver('follow')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(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.FollowerLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (this.query.userId !== followStatus.to || !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: (followStatus: Amity.InternalFollowStatus) => void) => Amity.Unsubscriber;
+      action: EnumFollowActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

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

@@ -1,24 +1,9 @@
-/* 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 { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 
-import {
-  onFollowerRequested,
-  onFollowRequestAccepted,
-  onFollowRequestDeclined,
-  onFollowRequestCanceled,
-  onUserFollowed,
-  onUserUnfollowed,
-  onFollowerDeleted,
-} from '../events';
-import { queryFollowers } from '../api/queryFollowers';
+import { FollowerLiveCollectionController } from './getFollowers/FollowerLiveCollectionController';
 
 /* begin_public_function
   id: user.relationship.query_my_followers, user.relationship.query_followers
@@ -49,101 +34,18 @@ export const getFollowers = (
   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();
   log(`getFollowers(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit, ...queryParams } = params;
+  const followerLiveCollection = new FollowerLiveCollectionController(params, callback);
+  const disposers = followerLiveCollection.startSubscription();
 
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+  const cacheKey = followerLiveCollection.getCacheKey();
 
-  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 = (action: Amity.FollowActionType) => (followStatus: Amity.FollowStatus) => {
-    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 = (initial = false) => {
-    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
-
-    const followers = collection?.data ?? [];
-
-    if (!initial && followers.length > 0 && !collection?.params?.page) return;
-
-    const query = createQuery(queryFollowers, {
-      ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { 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(realtimeRouter('onRequested')),
-    onFollowRequestAccepted(realtimeRouter('onAccepted')),
-    onFollowRequestDeclined(realtimeRouter('onDeclined')),
-    onFollowRequestCanceled(realtimeRouter('onCanceled')),
-    onUserFollowed(realtimeRouter('onFollowed')),
-    onUserUnfollowed(realtimeRouter('onUnfollowed')),
-    onFollowerDeleted(realtimeRouter('onDeleted')),
-  );
-
-  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`getFollowers(tmpid: ${timestamp}) > dispose`);