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

package/src/userRepository/api/unflagUser.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+
+/* begin_public_function
+  id: user.unflag
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const unflagged = await UserRepository.unflagUser('post', postId)
+ * ```
+ *
+ * @param userId The ID of the user to unflag
+ * @returns the deleted report result
+ *
+ * @category User API
+ * @async
+ * */
+export const unflagUser = async (userId: Amity.User['userId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('user/unflag', userId);
+
+  const { data } = await client.http.delete<Amity.UserPayload>(
+    `/api/v4/me/flags/${encodeURIComponent(userId)}`,
+  );
+
+  const payload = prepareUserPayload(data);
+
+  if (client.cache) {
+    ingestInCache(payload);
+  }
+
+  fireEvent('user.unflagged', data);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/userRepository/api/updateUser.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+
+/* begin_public_function
+  id: client.update_user
+*/
+/**
+ * ```js
+ * import { updateUser } from '@amityco/ts-sdk'
+ * const updated = await updateUser(userId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.User}
+ *
+ * @param userId The ID of the {@link Amity.User} to update
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.User} object
+ *
+ * @category User API
+ * @async
+ */
+export const updateUser = async (
+  userId: Amity.User['userId'],
+  patch: Patch<
+    Amity.User,
+    'displayName' | 'description' | 'avatarFileId' | 'avatarCustomUrl' | 'metadata'
+  >,
+): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/updateUser', userId, patch);
+
+  const { data } = await client.http.put<Amity.UserPayload>(`/api/v3/users/`, {
+    userId,
+    ...patch,
+    createNewUserWhenNotFound: false,
+  });
+
+  const payload = prepareUserPayload(data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload, { cachedAt });
+
+  fireEvent('user.updated', data);
+
+  return {
+    data: payload.users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/userRepository/constants/index.ts

@@ -0,0 +1,4 @@
+export enum AmityUserSearchMatchType {
+  DEFAULT = 'default',
+  PARTIAL = 'partial',
+}

package/src/userRepository/events/index.ts

@@ -0,0 +1,6 @@
+export * from './onUserUpdated';
+export * from './onUserDeleted';
+
+export * from './onUserFlagged';
+export * from './onUserUnflagged';
+export * from './onUserFlagCleared';

package/src/userRepository/events/onUserDeleted.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk'
+ * const dispose = onUserDeleted(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalUser} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserDeleted = (callback: Amity.Listener<Amity.InternalUser>) =>
+  createUserEventSubscriber('user.deleted', callback);

package/src/userRepository/events/onUserFetched.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFetched } from '@amityco/ts-sdk'
+ * const dispose = onUserFetched(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalUser} has been fetched
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFetched = (callback: Amity.Listener<Amity.InternalUser>) =>
+  createUserEventSubscriber('user.fetched', callback);

package/src/userRepository/events/onUserFlagCleared.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when flags have been cleared for a {@link Amity.InternalUser}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFlagCleared = (callback: Amity.Listener<Amity.InternalUser>) =>
+  createUserEventSubscriber('user.flagCleared', callback);

package/src/userRepository/events/onUserFlagged.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFlagged } from '@amityco/ts-sdk'
+ * const dispose = onUserFlagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalUser} has been flagged
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserFlagged = (callback: Amity.Listener<Amity.InternalUser>) =>
+  createUserEventSubscriber('user.flagged', callback);

package/src/userRepository/events/onUserUnflagged.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onUserUnflagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.InternalUser}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserUnflagged = (callback: Amity.Listener<Amity.InternalUser>) =>
+  createUserEventSubscriber('user.unflagged', callback);

package/src/userRepository/events/onUserUpdated.ts

@@ -0,0 +1,19 @@
+import { createUserEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUpdated } from '@amityco/ts-sdk'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalUser} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+export const onUserUpdated = (callback: Amity.Listener<Amity.InternalUser>) =>
+  createUserEventSubscriber('user.updated', callback);

package/src/userRepository/events/utils.ts

@@ -0,0 +1,24 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareUserPayload } from '../utils/prepareUserPayload';
+
+export const createUserEventSubscriber = (
+  event: keyof Amity.MqttUserEvents,
+  callback: Amity.Listener<Amity.InternalUser>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (data: Amity.UserPayload) => {
+    const payload = prepareUserPayload(data);
+
+    if (client.cache) {
+      ingestInCache(payload);
+    }
+
+    callback(payload.users[0]);
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/userRepository/index.ts

@@ -0,0 +1,6 @@
+export * as Relationship from './relationship';
+
+export * from './api';
+export * from './events';
+export * from './observers';
+export * from './constants';

package/src/userRepository/internalApi/getUser.ts

@@ -0,0 +1,85 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+
+/**
+ * ```js
+ * import { getUser } from '~/user/api'
+ * const { data: user } = await getUser('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category Private
+ * @async
+ */
+export const getUser = async (
+  userId: Amity.User['userId'],
+): Promise<Amity.Cached<Amity.InternalUser>> => {
+  const client = getActiveClient();
+  client.log('user/getUser', userId);
+
+  isInTombstone('user', userId);
+
+  try {
+    const { data } = await client.http.get<Amity.UserPayload>(
+      `/api/v3/users/${encodeURIComponent(userId)}`,
+    );
+
+    const cachedAt = client.cache && Date.now();
+    const payload = prepareUserPayload(data);
+    if (client.cache) ingestInCache(payload, { cachedAt });
+
+    fireEvent('user.fetched', data);
+
+    return {
+      data: payload.users.find(user => user.userId === userId)!,
+      cachedAt,
+    };
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('user', userId);
+    }
+
+    throw error;
+  }
+};
+
+/**
+ * ```js
+ * import { getUser } from '@amityco/ts-sdk'
+ * const { data: user } = getUser.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.User} object from cache
+ *
+ * @param userId the ID of the {@link Amity.User} to fetch
+ * @returns the associated {@link Amity.User} object
+ *
+ * @category User API
+ */
+getUser.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.InternalUser> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getUser.locally', userId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.InternalUser>(['user', 'get', userId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/userRepository/internalApi/queryUsers.ts

@@ -0,0 +1,126 @@
+import { getActiveClient } from '~/client/api';
+
+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
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.InternalUser} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.InternalUser} objects
+ *
+ * @category User API
+ * @async
+ */
+export const queryUsers = async (
+  query: Amity.QueryUsers = {},
+): Promise<Amity.Cached<Amity.PageToken<Amity.InternalUser>>> => {
+  const client = getActiveClient();
+  client.log('user/queryUsers', query);
+
+  const { page, limit = 10, filter = 'all', sortBy = 'displayName', ...params } = query;
+
+  const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(`/api/v3/users`, {
+    params: {
+      ...params,
+      filter,
+      sortBy,
+      options: page ? { token: page } : { limit },
+    },
+  });
+
+  // unpacking
+  const { paging, ...rawPayload } = data;
+  const { users } = rawPayload;
+
+  const cachedAt = client.cache && Date.now();
+
+  const payload = prepareUserPayload(rawPayload);
+
+  if (client.cache) {
+    ingestInCache(payload, { cachedAt });
+
+    /*
+     * using a query as a cache key over params because if the keyword, filter, sort
+     * change the API will NOT cache results, when it should
+     */
+    const cacheKey = [
+      'user',
+      'query',
+      { ...query, options: { limit, token: page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
+  }
+
+  fireEvent('user.fetched', data);
+
+  return {
+    data: payload.users,
+    cachedAt,
+    paging,
+  };
+};
+
+/**
+ * ```js
+ * import { queryUsers } from '@amityco/ts-sdk'
+ * const { data: users } = queryUsers.locally({ keyword: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.InternalUser} objects from cache
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.InternalUser} objects
+ *
+ * @category User API
+ */
+queryUsers.locally = (
+  query: Parameters<typeof queryUsers>[0] = {},
+): Amity.Cached<Amity.PageToken<Amity.InternalUser>> | undefined => {
+  const client = getActiveClient();
+  client.log('user/queryUsers.locally', query);
+
+  if (!client.cache) return;
+
+  const { limit = 10, page } = query ?? {};
+
+  const cacheKey = [
+    'user',
+    'query',
+    {
+      ...query,
+      options: {
+        limit,
+        token: page,
+      },
+    } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<{ users: Pick<Amity.InternalUser, 'userId'>[] } & Amity.Pagination>(cacheKey) ??
+    {};
+
+  const users: Amity.InternalUser[] =
+    data?.users
+      .map(userId => pullFromCache<Amity.InternalUser>(['user', 'get', userId])!)
+      .filter(Boolean)
+      .map(({ data }) => data) ?? [];
+
+  return users.length > 0 && users.length === data?.users?.length
+    ? {
+        data: users,
+        cachedAt,
+        paging: data?.paging,
+      }
+    : undefined;
+};

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,117 @@
+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';
+import { onLocalUserFollowed, onUserFollowed } from '~/userRepository/relationship/follow/events';
+import { convertEventPayload } from '~/utils/event';
+import { EnumFollowActions } from '~/userRepository/relationship/follow/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,
+      },
+      // In the case of unblocking a user, we need to subscribe to the follow events
+      {
+        fn: convertEventPayload(onLocalUserFollowed, 'to', 'user'),
+        action: EnumFollowActions.OnFollowed,
+      },
+      {
+        fn: convertEventPayload(onUserFollowed, 'to', 'user'),
+        action: EnumFollowActions.OnFollowed,
+      },
+    ]);
+  }
+
+  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;
+  }
+}