@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

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

@@ -0,0 +1,84 @@
+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';
+import { EnumFollowActions } from '~/userRepository/relationship/follow/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 | EnumFollowActions) {
+    return (targetUser: Amity.InternalUser) => {
+      if (action === EnumFollowActions.OnFollowed) {
+        const collection = pullFromCache<Amity.BlockedUserLiveCollectionCache>(this.cacheKey)?.data;
+        const updatedCollection = collection?.data.filter(id => id !== targetUser.userId);
+
+        pushToCache(this.cacheKey, {
+          ...collection,
+          data: updatedCollection,
+        });
+      }
+
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (user: Amity.InternalUser) => void) => Amity.Unsubscriber;
+      action: EnumUserActions | EnumFollowActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/userRepository/observers/getBlockedUsers.ts

@@ -0,0 +1,51 @@
+import { getActiveClient } from '~/client';
+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
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const unblockedUser = await UserRepository.blockUser('userId')
+ * ```
+ *
+ * Blocks a {@link Amity.User}
+ *
+ * @param params The params to get blocked {@link Amity.User}s
+ * @param callback to recieve updates on unblocked {@link Amity.User}s
+ * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
+ *
+ * @category Post API
+ * @async
+ */
+export const getBlockedUsers = (
+  params: Amity.BlockedUsersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
+
+  const blockedUserLiveCollection = new BlockedUserLiveCollectionController(params, callback);
+  const disposers = blockedUserLiveCollection.startSubscription();
+
+  const cacheKey = blockedUserLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getBlockedUsers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+    dropFromCache(cacheKey);
+  };
+};
+/* end_public_function */

package/src/userRepository/observers/getReachedUsers.ts

@@ -0,0 +1,100 @@
+import { getActiveClient } from '~/client';
+import { COLLECTION_DEFAULT_CACHING_POLICY, ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { createQuery, queryOptions, runQuery } from '~/core/query';
+import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
+import { queryReachUser } from '~/analytic/api/queryReachUser';
+
+export const getReachedUsers = (
+  params: Amity.ViewedUsersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User | undefined>,
+): Amity.Unsubscriber => {
+  // Pre-defined function to avoid undefined function call
+  let onFetch = (initial = false): void => undefined;
+
+  const { log, cache } = getActiveClient();
+  const cacheKey = [
+    'viewedUsers',
+    'collection',
+    { viewId: params.viewId, viewedType: params.viewedType },
+  ];
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getReachUsers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, viewId, viewedType } = params;
+
+  const responder = (snapshot: {
+    loading?: boolean;
+    params?: { page: { next: Amity.Token; previous?: Amity.Token } };
+    data: Amity.User['userId'][];
+  }) => {
+    let users: (Amity.User | undefined)[] = [];
+
+    if (snapshot?.data) {
+      users =
+        snapshot.data
+          .map((userId: Amity.User['userId']) => pullFromCache<Amity.User>(['user', 'get', userId]))
+          .filter(Boolean)
+          .map(data => data?.data) || [];
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: users,
+      hasNextPage: !!snapshot.params?.page?.next,
+      loading: snapshot.loading || false,
+    });
+  };
+
+  onFetch = (initial = false) => {
+    const collection = pullFromCache<Amity.PostViewedUsersLiveCollectionCache>(cacheKey)?.data;
+
+    const users = collection?.data ?? [];
+
+    if (!initial && users.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryReachUser, {
+      viewId,
+      viewedType,
+      limit: queryLimit || 10,
+      token: !initial ? collection?.params.page?.next : undefined,
+    });
+
+    runQuery(
+      query,
+      result => {
+        let userIds =
+          pullFromCache<Amity.PostViewedUsersLiveCollectionCache>(cacheKey)?.data?.data ?? [];
+
+        if (result.data?.users) {
+          userIds = [
+            ...new Set([...userIds, ...result.data.users.map(({ userId }: Amity.User) => userId)]),
+          ];
+        }
+
+        const saveToCache = {
+          loading: result.loading,
+          params: { page: result.data?.paging },
+          data: userIds || [],
+        };
+
+        pushToCache(cacheKey, saveToCache);
+
+        responder(saveToCache);
+      },
+      queryOptions(COLLECTION_DEFAULT_CACHING_POLICY, CACHE_SHORTEN_LIFESPAN),
+    );
+  };
+
+  onFetch(true);
+
+  return () => {
+    log(`getReachUsers(tmpid: ${timestamp}) > dispose`);
+    dropFromCache(cacheKey);
+  };
+};

package/src/userRepository/observers/getUser.ts

@@ -0,0 +1,57 @@
+import { liveObject } from '~/utils/liveObject';
+import {
+  onUserDeleted,
+  onUserUpdated,
+  onUserFlagCleared,
+  onUserFlagged,
+  onUserUnflagged,
+} from '../events';
+import { onUserFetched } from '../events/onUserFetched';
+import { getUser as _getUser } from '../internalApi/getUser';
+import { LinkedObject } from '~/utils/linkedObject';
+
+/* begin_public_function
+  id: user.get
+*/
+/**
+ * ```js
+ * import { liveUser } from '@amityco/ts-sdk';
+ *
+ * let user;
+ *
+ * const unsubscribe = liveUser(userId, response => {
+ *   user = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.User}
+ *
+ * @param userId the ID of the user to observe
+ * @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 user
+ *
+ * @category Message Live Object
+ */
+export const getUser = (
+  userId: Amity.User['userId'],
+  callback: Amity.LiveObjectCallback<Amity.User>,
+): Amity.Unsubscriber => {
+  const reactor = (
+    response: Amity.LiveObject<Amity.InternalUser>,
+  ): Amity.LiveObjectCallback<Amity.User> => {
+    return callback({
+      ...response,
+      data: response.data ? LinkedObject.user(response.data) : response.data,
+    });
+  };
+
+  return liveObject(userId, reactor, 'userId', _getUser, [
+    onUserFetched,
+    onUserUpdated,
+    onUserDeleted,
+    onUserFlagged,
+    onUserUnflagged,
+    onUserFlagCleared,
+  ]);
+};
+/* end_public_function */

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

@@ -0,0 +1,127 @@
+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;
+
+    const sortFn = (() => {
+      switch (this.query.sortBy) {
+        case 'firstCreated':
+          return sortByFirstCreated;
+        case 'lastCreated':
+          return sortByLastCreated;
+        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,24 @@
+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, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.UserPayload & Amity.Pagination>(
+      `/api/v3/users`,
+      {
+        params: {
+          ...params,
+          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)));
+  }
+}

package/src/userRepository/observers/getUsers.ts

@@ -0,0 +1,54 @@
+import { dropFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { UserLiveCollectionController } from './getUsers/UserLiveCollectionController';
+
+/* begin_public_function
+  id: user.query
+*/
+/**
+ * ```js
+ * import { liveUsers } from '@amityco/ts-sdk'
+ *
+ * let users = []
+ * const unsub = liveUsers({}, response => merge(users, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.User}s
+ *
+ * @param params for querying users
+ * @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 users
+ *
+ * @category Category Live Collection
+ */
+export const getUsers = (
+  params: Amity.UserLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.User>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    // eslint-disable-next-line no-console
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveUsers(tmpid: ${timestamp}) > listen`);
+
+  const usersLiveCollection = new UserLiveCollectionController(params, callback);
+  const disposers = usersLiveCollection.startSubscription();
+
+  const cacheKey = usersLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`liveUsers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/userRepository/observers/index.ts

@@ -0,0 +1,5 @@
+export { getUser } from './getUser';
+export { getUsers } from './getUsers';
+export { getBlockedUsers } from './getBlockedUsers';
+export { searchUserByDisplayName } from './searchUserByDisplayName';
+export { getReachedUsers } from './getReachedUsers';