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

package/src/userRepository/observers/getUsers.ts

@@ -1,63 +1,9 @@
-/* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
-import { pullFromCache, pushToCache } from '~/cache/api';
+import { dropFromCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
-import { uuid } from '~/core/uuid';
 
-import {
-  createQuery,
-  filterByStringComparePartially,
-  queryOptions,
-  runQuery,
-  sortByDisplayName,
-  sortByFirstCreated,
-  sortByLastCreated,
-} from '~/core/query';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-  ENABLE_CACHE_MESSAGE,
-} from '~/utils/constants';
-
-import { LinkedObject } from '~/utils/linkedObject';
-import { queryUsers } from '../internalApi/queryUsers';
-import {
-  onUserDeleted,
-  onUserFlagCleared,
-  onUserFlagged,
-  onUserUnflagged,
-  onUserUpdated,
-} from '../events';
-
-/*
- * Exported for testing
- * @hidden
- */
-export const applyFilter = <T extends Amity.User>(
-  data: T[],
-  params: Amity.UserLiveCollection,
-): T[] => {
-  let users = filterByStringComparePartially(data, 'displayName', params.displayName);
-
-  switch (params.sortBy) {
-    case 'firstCreated':
-      users = users.sort(sortByFirstCreated);
-      break;
-
-    case 'lastCreated':
-      users = users.sort(sortByLastCreated);
-      break;
-
-    default:
-      users = users
-        // this needs to be aligned with the backend data type
-        .map(u => (u.displayName ? u : { ...u, displayName: '' }))
-        .sort(sortByDisplayName);
-  }
-
-  return users;
-};
+import { UserLiveCollectionController } from './getUsers/UserLiveCollectionController';
 
 /* begin_public_function
   id: user.query
@@ -93,88 +39,12 @@ export const getUsers = (
   const timestamp = Date.now();
   log(`liveUsers(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 = ['user', 'collection', uuid()];
-
-  const responder = (data: Amity.UserLiveCollectionCache, isEventModel = false) => {
-    const users: Amity.User[] =
-      data.data
-        .map(userId => pullFromCache<Amity.User>(['user', 'get', userId])!)
-        .filter(Boolean)
-        .map(({ data }) => LinkedObject.user(data)) ?? [];
-
-    callback({
-      onNextPage: onFetch,
-      /*
-       * Only apply filter to RTE Model
-       */
-      data: isEventModel ? applyFilter(users, params) : users,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (_: Amity.UserActionType) => (user: Amity.User) => {
-    const collection = pullFromCache<Amity.UserLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
-
-    collection.data = [...new Set([user.userId, ...collection.data])];
-    pushToCache(cacheKey, collection);
-    responder(collection, true);
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.UserLiveCollectionCache>(cacheKey)?.data;
-
-    const users = collection?.data ?? [];
-
-    if (!initial && users.length > 0 && !collection?.params.page) return;
-
-    const pagingCondition = initial ? { limit } : { page: collection?.params.page };
-    const query = createQuery(queryUsers, {
-      ...queryParams,
-      ...pagingCondition,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, paging }) => {
-        const data = {
-          loading,
-          error,
-          params: { page: paging?.next },
-          data: users,
-        };
-
-        if (result) {
-          data.data = initial
-            ? result.map(getResolver('user'))
-            : [...new Set([...users, ...result.map(getResolver('user'))])];
-        }
-
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy),
-    );
-  };
+  const usersLiveCollection = new UserLiveCollectionController(params, callback);
+  const disposers = usersLiveCollection.startSubscription();
 
-  disposers.push(
-    onUserUpdated(realtimeRouter('onUpdate')),
-    onUserDeleted(realtimeRouter('onDelete')),
-    onUserFlagged(realtimeRouter('onFlagged')),
-    onUserUnflagged(realtimeRouter('onUnflagged')),
-    onUserFlagCleared(realtimeRouter('onFlagCleared')),
-  );
+  const cacheKey = usersLiveCollection.getCacheKey();
 
-  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
     log(`liveUsers(tmpid: ${timestamp}) > dispose`);

package/src/userRepository/observers/searchUserByDisplayName/SearchUserLiveCollectionController.ts

@@ -0,0 +1,116 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { SearchUserPaginationController } from './SearchUserPaginationController';
+import { SearchUserQueryStreamController } from './SearchUserQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onUserDeleted,
+  onUserFlagCleared,
+  onUserFlagged,
+  onUserUnflagged,
+  onUserUpdated,
+} from '~/userRepository/events';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+import { EnumUserActions } from '~/userRepository/observers/enums';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export class SearchUserLiveCollectionController extends LiveCollectionController<
+  'user',
+  Amity.SearchUserLiveCollection,
+  Amity.User,
+  SearchUserPaginationController
+> {
+  private queryStreamController: SearchUserQueryStreamController;
+
+  private query: Amity.SearchUserLiveCollection;
+
+  constructor(
+    query: Amity.SearchUserLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.User>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['user', 'collection', queryStreamId];
+    const paginationController = new SearchUserPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = { ...query, filter: query.filter ?? 'all' };
+    this.queryStreamController = new SearchUserQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareUserPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.UserLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.UserPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'user'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onUserDeleted, action: EnumUserActions.OnUserDeleted },
+      { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+      { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+      { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+      { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.UserLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalUser>(['user', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data)
+        .map(LinkedObject.user) ?? [],
+    );
+
+    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.InternalUser[]) {
+    let users = data;
+
+    if (this.query.filter === 'flagged') {
+      users = users.filter(user => !!user.hashFlag);
+    }
+
+    users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+
+    return users;
+  }
+}

package/src/userRepository/observers/searchUserByDisplayName/SearchUserPaginationController.ts

@@ -0,0 +1,25 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class SearchUserPaginationController extends PaginationController<
+  'user',
+  Amity.SearchUserLiveCollection
+> {
+  async getRequest(queryParams: Amity.SearchUserLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.UserPayload & Amity.Pagination>(
+      `/api/v3/users`,
+      {
+        params: {
+          ...params,
+          keyword: displayName,
+          options,
+          isDeleted: false,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/userRepository/observers/searchUserByDisplayName/SearchUserQueryStreamController.ts

@@ -0,0 +1,82 @@
+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 { EnumUserActions } from '~/userRepository/observers/enums';
+
+export class SearchUserQueryStreamController extends QueryStreamController<
+  Amity.UserPayload,
+  Amity.SearchUserLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.UserPayload) => Amity.ProcessedUserPayload;
+
+  constructor(
+    query: Amity.SearchUserLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.UserPayload) => Amity.ProcessedUserPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.UserPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.UserPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.users.map(getResolver('user')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.UserLiveCollectionCache>(this.cacheKey)?.data;
+
+      const users = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...users, ...response.users.map(getResolver('user'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumUserActions) {
+    return (user: Amity.InternalUser) => {
+      const collection = pullFromCache<Amity.UserLiveCollectionCache>(this.cacheKey)?.data;
+      if (!collection) return;
+
+      /*
+       * Simply update a collection and let responder decide what to do with data
+       */
+      collection.data = [...new Set([user.userId, ...collection.data])];
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (user: Amity.InternalUser) => void) => Amity.Unsubscriber;
+      action: EnumUserActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/userRepository/observers/searchUserByDisplayName.ts

@@ -1,4 +1,8 @@
+import { getActiveClient } from '~/client';
 import { getUsers } from './getUsers';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { SearchUserLiveCollectionController } from './searchUserByDisplayName/SearchUserLiveCollectionController';
+import { dropFromCache } from '~/cache/api';
 
 /* begin_public_function
   id: user.search
@@ -25,6 +29,26 @@ export const searchUserByDisplayName = (
   callback: Amity.LiveCollectionCallback<Amity.InternalUser>,
   config?: Amity.LiveCollectionConfig,
 ) => {
-  return getUsers({ ...params, filter: 'all' }, callback, config);
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    // eslint-disable-next-line no-console
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveSearchUsers(tmpid: ${timestamp}) > listen`);
+
+  const searchUsersLiveCollection = new SearchUserLiveCollectionController(params, callback);
+  const disposers = searchUsersLiveCollection.startSubscription();
+
+  const cacheKey = searchUsersLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`liveSearchUsers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
 };
 /* end_public_function */

package/src/userRepository/relationship/block/api/blockUser.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 import { upsertInCache } from '~/cache/api';
+import { prepareFollowStatusPayload } from '../../follow/utils';
 
 /* begin_public_function
   id: user.relationship.block
@@ -39,7 +40,9 @@ export const blockUser = async (
     upsertInCache(['followInfo', 'get', userId], followCounts[0], { cachedAt });
   }
 
-  fireEvent('follow.unfollowed', followStatus);
+  const payload = prepareFollowStatusPayload(followStatus);
+
+  fireEvent('local.follow.unfollowed', payload);
 
   return data;
 };

package/src/userRepository/relationship/block/api/unBlockUser.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 import { upsertInCache } from '~/cache/api';
+import { prepareFollowStatusPayload } from '../../follow/utils';
 
 /* begin_public_function
   id: user.relationship.unblock
@@ -41,7 +42,9 @@ export const unBlockUser = async (
     upsertInCache(['followInfo', 'get', userId], followCounts[0], { cachedAt });
   }
 
-  fireEvent('follow.created', followStatus);
+  const payload = prepareFollowStatusPayload(followStatus);
+
+  fireEvent('local.follow.created', payload);
 
   return data;
 };

package/src/userRepository/relationship/follow/api/acceptFollower.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareFollowStatusPayload } from '../utils';
 
 /**
  * @deprecated This API renamed to `acceptMyFollower`.
@@ -31,7 +32,9 @@ export const acceptFollower = async (userId: Amity.InternalUser['userId']): Prom
     ingestInCache(data);
   }
 
-  fireEvent('follow.accepted', data);
+  const payload = prepareFollowStatusPayload(data);
+
+  fireEvent('local.follow.accepted', payload);
 
   return true;
 };

package/src/userRepository/relationship/follow/api/acceptMyFollower.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareFollowStatusPayload } from '../utils';
 
 /* begin_public_function
   id: user.relationship.accept_follow
@@ -31,7 +32,9 @@ export const acceptMyFollower = async (userId: Amity.InternalUser['userId']): Pr
     ingestInCache(data);
   }
 
-  fireEvent('follow.accepted', data);
+  const payload = prepareFollowStatusPayload(data);
+
+  fireEvent('local.follow.accepted', payload);
 
   return true;
 };

package/src/userRepository/relationship/follow/api/declineFollower.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareFollowStatusPayload } from '../utils';
 
 /**
  * @deprecated This API renamed to `declineMyFollower`.
@@ -23,7 +24,7 @@ export const declineFollower = async (userId: Amity.InternalUser['userId']): Pro
   const client = getActiveClient();
   client.log('follow/declineFollower', userId);
 
-  const { data } = await client.http.delete<{ follows: Amity.FollowStatus[] }>(
+  const { data } = await client.http.delete<Amity.FollowStatusPayload>(
     `/api/v4/me/followers/${userId}`,
   );
 
@@ -31,7 +32,9 @@ export const declineFollower = async (userId: Amity.InternalUser['userId']): Pro
     ingestInCache(data);
   }
 
-  fireEvent('follow.requestDeclined', data);
+  const payload = prepareFollowStatusPayload(data);
+
+  fireEvent('local.follow.requestDeclined', payload);
 
   return true;
 };

package/src/userRepository/relationship/follow/api/declineMyFollower.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareFollowStatusPayload } from '../utils';
 
 /* begin_public_function
   id: user.relationship.decline_follow
@@ -23,7 +24,7 @@ export const declineMyFollower = async (userId: Amity.InternalUser['userId']): P
   const client = getActiveClient();
   client.log('follow/declineMyFollower', userId);
 
-  const { data } = await client.http.delete<{ follows: Amity.FollowStatus[] }>(
+  const { data } = await client.http.delete<Amity.FollowStatusPayload>(
     `/api/v4/me/followers/${userId}`,
   );
 
@@ -31,7 +32,9 @@ export const declineMyFollower = async (userId: Amity.InternalUser['userId']): P
     ingestInCache(data);
   }
 
-  fireEvent('follow.requestDeclined', data);
+  const payload = prepareFollowStatusPayload(data);
+
+  fireEvent('local.follow.requestDeclined', payload);
 
   return true;
 };

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

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareFollowStatusPayload } from '../utils';
 
 /* begin_public_function
   id: user.relationship.follow
@@ -35,7 +36,13 @@ export const follow = async (
     ingestInCache(data, { cachedAt });
   }
 
-  fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
+  const payload = prepareFollowStatusPayload(data);
+
+  if (data.follows[0].status === 'accepted') {
+    fireEvent('local.follow.created', payload);
+  } else {
+    fireEvent('local.follow.requested', payload);
+  }
 
   return {
     data: data.follows[0],

package/src/userRepository/relationship/follow/api/unfollow.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareFollowStatusPayload } from '../utils';
 
 /* begin_public_function
   id: user.relationship.unfollow
@@ -31,7 +32,9 @@ export const unfollow = async (userId: Amity.InternalUser['userId']): Promise<bo
     ingestInCache(data);
   }
 
-  fireEvent('follow.unfollowed', data);
+  const payload = prepareFollowStatusPayload(data);
+
+  fireEvent('local.follow.unfollowed', payload);
 
   return true;
 };

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

@@ -3,6 +3,7 @@ import { toPageRaw, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
+import { prepareFollowersPayload } from '../utils';
 
 export const queryFollows = async (
   key: 'followers' | 'following',
@@ -28,12 +29,15 @@ export const queryFollows = async (
   );
 
   const { paging, ...payload } = data;
-  const { follows } = payload;
 
   const cachedAt = client.cache && Date.now();
 
+  const preparedPayload = prepareFollowersPayload(payload);
+
+  const { follows } = preparedPayload;
+
   if (client.cache) {
-    ingestInCache(payload as Amity.FollowersPayload, { cachedAt });
+    ingestInCache(preparedPayload, { cachedAt });
 
     const cacheKey = [
       'follow',

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

@@ -0,0 +1,10 @@
+export enum EnumFollowActions {
+  OnRequested = 'onRequested',
+  OnAccepted = 'onAccepted',
+  OnDeclined = 'onDeclined',
+  OnCanceled = 'onCanceled',
+  OnFollowed = 'onFollowed',
+  OnUnfollowed = 'onUnfollowed',
+  OnDeleted = 'onDeleted',
+  OnUserDeleted = 'onUserDeleted',
+}

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

@@ -8,3 +8,9 @@ export * from './onFollowRequestAccepted';
 export * from './onFollowRequestDeclined';
 
 export * from './onFollowInfoUpdated';
+
+export * from './onLocalUserFollowed';
+export * from './onLocalUserUnfollowed';
+export * from './onLocalFollowerRequested';
+export * from './onLocalFollowRequestAccepted';
+export * from './onLocalFollowRequestDeclined';

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

@@ -1,4 +1,4 @@
-import { createFollowEventSubscriber } from './utils';
+import { createFollowEventSubscriber, createLocalFollowEventSubscriber } from './utils';
 import { getFollowInfo } from '../api/getFollowInfo';
 
 /**
@@ -37,6 +37,11 @@ export const onFollowInfoUpdated = (
     createFollowEventSubscriber('follow.requestCanceled', handler),
     createFollowEventSubscriber('follow.requestDeclined', handler),
     createFollowEventSubscriber('follow.followerDeleted', handler),
+    createLocalFollowEventSubscriber('local.follow.created', handler),
+    createLocalFollowEventSubscriber('local.follow.requested', handler),
+    createLocalFollowEventSubscriber('local.follow.accepted', handler),
+    createLocalFollowEventSubscriber('local.follow.unfollowed', handler),
+    createLocalFollowEventSubscriber('local.follow.requestDeclined', handler),
   ];
 
   return () => {