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

package/src/userRepository/internalApi/queryUsers.ts

@@ -4,6 +4,7 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { fireEvent } from '~/core/events';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
 
 /**
  * ```js
@@ -46,13 +47,15 @@ export const queryUsers = async (
   });
 
   // unpacking
-  const { paging, ...payload } = data;
-  const { users } = payload;
+  const { paging, ...rawPayload } = data;
+  const { users } = rawPayload;
 
   const cachedAt = client.cache && Date.now();
 
+  const payload = prepareUserPayload(rawPayload);
+
   if (client.cache) {
-    ingestInCache(payload as Amity.UserPayload, { cachedAt });
+    ingestInCache(payload, { cachedAt });
 
     /*
      * using a query as a cache key over params because if the keyword, filter, sort
@@ -69,7 +72,7 @@ export const queryUsers = async (
   fireEvent('user.fetched', data);
 
   return {
-    data: users,
+    data: payload.users,
     cachedAt,
     paging,
   };

package/src/userRepository/observers/enums.ts

@@ -0,0 +1,7 @@
+export enum EnumUserActions {
+  OnUserDeleted = 'onUserDeleted',
+  OnUserUpdated = 'onUserUpdated',
+  OnUserFlagged = 'onUserFlagged',
+  OnUserUnflagged = 'onUserUnflagged',
+  OnUserFlagCleared = 'onUserFlagCleared',
+}

package/src/userRepository/observers/getBlockedUsers/BlockedUserLiveCollectionController.ts

@@ -0,0 +1,106 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { BlockedUserPaginationController } from './BlockedUserPaginationController';
+import { BlockedUserQueryStreamController } from './BlockedUserQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { isNonNullable } from '~/utils';
+import { prepareBlockedUserPayload } from '~/userRepository/utils/prepareBlockedUserPayload';
+import { LinkedObject } from '~/utils/linkedObject';
+import { onUserDeleted } from '~/userRepository/events';
+import { EnumUserActions } from '../enums';
+
+export class BlockedUserLiveCollectionController extends LiveCollectionController<
+  'blockUser',
+  Amity.BlockedUsersLiveCollection,
+  Amity.User,
+  BlockedUserPaginationController
+> {
+  private queryStreamController: BlockedUserQueryStreamController;
+
+  private query: Amity.BlockedUsersLiveCollection;
+
+  constructor(
+    query: Amity.BlockedUsersLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.User>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['blockedUsers', 'collection', queryStreamId];
+    const paginationController = new BlockedUserPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new BlockedUserQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareBlockedUserPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.BlockedUserPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'blockUser'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      {
+        fn: onUserDeleted,
+        action: EnumUserActions.OnUserDeleted,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(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,
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  applyFilter(data: Amity.InternalUser[]) {
+    let users = data;
+
+    users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+
+    return users;
+  }
+}

package/src/userRepository/observers/getBlockedUsers/BlockedUserPaginationController.ts

@@ -0,0 +1,24 @@
+import { getActiveClient } from '~/client';
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class BlockedUserPaginationController extends PaginationController<
+  'blockUser',
+  Amity.BlockedUsersLiveCollection
+> {
+  async getRequest(queryParams: Amity.BlockedUsersLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.BlockedUserPayload & Amity.Pagination
+    >('/api/v4/me/user-blocks', {
+      params: {
+        ...params,
+        options,
+        isDeleted: false,
+      },
+    });
+    return queryResponse;
+  }
+}

package/src/userRepository/observers/getBlockedUsers/BlockedUserQueryStreamController.ts

@@ -0,0 +1,76 @@
+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 '../enums';
+
+export class BlockedUserQueryStreamController extends QueryStreamController<
+  Amity.BlockedUserPayload,
+  Amity.BlockedUsersLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.BlockedUserPayload) => Amity.ProcessedBlockedUserPayload;
+
+  constructor(
+    query: Amity.BlockedUsersLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.BlockedUserPayload) => Amity.ProcessedBlockedUserPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.BlockedUserPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.BlockedUserPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.users.map(getResolver('user')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(this.cacheKey)?.data;
+
+      const users = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...users, ...response.users.map(getResolver('user'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumUserActions) {
+    return (followStatus: Amity.InternalUser) => {
+      const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(this.cacheKey)?.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/getBlockedUsers.ts

@@ -1,16 +1,7 @@
-/* eslint-disable no-use-before-define */
 import { getActiveClient } from '~/client';
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-  ENABLE_CACHE_MESSAGE,
-} from '~/utils/constants';
-import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
-import { createQuery, queryOptions, runQuery, toToken } from '~/core/query';
-import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
-import { getResolver } from '~/core/model';
-import { queryBlockedUsers } from '../api/queryBlockedUsers';
-import { LinkedObject } from '~/utils/linkedObject';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache } from '~/cache/api';
+import { BlockedUserLiveCollectionController } from './getBlockedUsers/BlockedUserLiveCollectionController';
 
 /* begin_public_function
   id: user.get_blocked_users
@@ -44,79 +35,15 @@ export const getBlockedUsers = (
   const timestamp = Date.now();
   log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit } = params;
+  const blockedUserLiveCollection = new BlockedUserLiveCollectionController(params, callback);
+  const disposers = blockedUserLiveCollection.startSubscription();
 
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+  const cacheKey = blockedUserLiveCollection.getCacheKey();
 
-  const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['blockedUsers', 'collection', {}];
-
-  const responder = (data: Amity.BlockedUserLiveCollectionCache) => {
-    const users: Amity.InternalUser[] =
-      data.data
-        .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
-        .filter(Boolean)
-        .map(({ data }) => LinkedObject.user(data)) ?? [];
-
-    callback({
-      onNextPage: onFetch,
-      data: users,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  /*
-   * const realtimeRouter = () => {
-   * @TODO: At the time of creating this api blocked user do not have any
-   * observers
-   *};
-   */
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(cacheKey)?.data;
-
-    const users = collection?.data ?? [];
-
-    if (!initial && users.length > 0 && !collection?.params.page) return;
-
-    const query = createQuery(queryBlockedUsers, {
-      limit,
-      token: toToken(!initial ? collection?.params.page : undefined, 'afterbeforeraw'),
-    });
-
-    runQuery(
-      query,
-      // @ts-ignore
-      ({ data: result, loading, error, nextPage: page, total }) => {
-        const data = {
-          loading,
-          error,
-          params: { page, total },
-          data: users,
-        };
-
-        if (result) {
-          data.data = [...new Set([...users, ...result.map(getResolver('user'))])];
-        }
-
-        pushToCache(cacheKey, data);
-        responder(data);
-      },
-      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
-
-  disposers.push(() => {
-    // @TODO -> update once observers added
-  });
-
-  onFetch(true);
+  disposers.push(() => dropFromCache(cacheKey));
 
   return () => {
-    log(`getCategories(tmpid: ${timestamp}) > dispose`);
+    log(`getBlockedUsers(tmpid: ${timestamp}) > dispose`);
     disposers.forEach(fn => fn());
     dropFromCache(cacheKey);
   };

package/src/userRepository/observers/getUsers/UserLiveCollectionController.ts

@@ -0,0 +1,131 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { UserPaginationController } from './UserPaginationController';
+import { UserQueryStreamController } from './UserQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onUserDeleted,
+  onUserFlagCleared,
+  onUserFlagged,
+  onUserUnflagged,
+  onUserUpdated,
+} from '~/userRepository/events';
+import { sortByDisplayName, sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+import { EnumUserActions } from '~/userRepository/observers/enums';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export class UserLiveCollectionController extends LiveCollectionController<
+  'user',
+  Amity.UserLiveCollection,
+  Amity.User,
+  UserPaginationController
+> {
+  private queryStreamController: UserQueryStreamController;
+
+  private query: Amity.UserLiveCollection;
+
+  constructor(query: Amity.UserLiveCollection, callback: Amity.LiveCollectionCallback<Amity.User>) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['user', 'collection', queryStreamId];
+    const paginationController = new UserPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new UserQueryStreamController(
+      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.displayName) {
+      const sortFn = (() => {
+        switch (this.query.sortBy) {
+          case 'firstCreated':
+            return sortByFirstCreated;
+          case 'lastCreated':
+            return sortByLastCreated;
+          case 'displayName':
+            return sortByDisplayName;
+          default:
+            return sortByLastCreated;
+        }
+      })();
+
+      users = users.sort(sortFn);
+    }
+
+    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/getUsers/UserPaginationController.ts

@@ -0,0 +1,25 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class UserPaginationController extends PaginationController<
+  'user',
+  Amity.UserLiveCollection
+> {
+  async getRequest(queryParams: Amity.UserLiveCollection, 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/getUsers/UserQueryStreamController.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 UserQueryStreamController extends QueryStreamController<
+  Amity.UserPayload,
+  Amity.UserLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.UserPayload) => Amity.ProcessedUserPayload;
+
+  constructor(
+    query: Amity.UserLiveCollection,
+    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)));
+  }
+}