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

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

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onFollowRequestCanceled } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestCanceled(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been canceled
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestCanceled = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requestCanceled', callback);

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

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onFollowRequestDeclined } from '@amityco/ts-sdk'
+ * const dispose = onFollowRequestDeclined(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follow request has been declined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowRequestDeclined = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requestDeclined', callback);

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

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onFollowerDeleted } from '@amityco/ts-sdk'
+ * const dispose = onFollowerDeleted(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a follower has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowerDeleted = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.followerDeleted', callback);

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

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onFollowerRequested } from '@amityco/ts-sdk'
+ * const dispose = onFollowerRequested(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user follows another users and confirmation is required
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onFollowerRequested = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.requested', callback);

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/onUserFollowed.ts

@@ -0,0 +1,19 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserFollowed } from '@amityco/ts-sdk'
+ * const dispose = onUserFollowed(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user follows another users and confirmation is not required
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onUserFollowed = (callback: Amity.Listener<Amity.FollowStatus>): Amity.Unsubscriber =>
+  createFollowEventSubscriber('follow.created', callback);

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

@@ -0,0 +1,20 @@
+import { createFollowEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onUserUnfollowed } from '@amityco/ts-sdk'
+ * const dispose = onUserFollowed(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user unfollows
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Follow Events
+ */
+export const onUserUnfollowed = (
+  callback: Amity.Listener<Amity.FollowStatus>,
+): Amity.Unsubscriber => createFollowEventSubscriber('follow.unfollowed', callback);

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

@@ -0,0 +1,47 @@
+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.InternalFollowStatus>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (data: Amity.FollowersPayload) => {
+    const payload = prepareFollowersPayload(data);
+
+    if (!client.cache) {
+      callback(payload.follows[0]);
+    } else {
+      ingestInCache(payload);
+
+      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]);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

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

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './events';
+export * from './observers';

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

@@ -0,0 +1,35 @@
+import { liveObject } from '~/utils/liveObject';
+import { getFollowInfo as _getFollowInfo } from '../api/getFollowInfo';
+import { onFollowInfoUpdated } from '../events';
+
+/* begin_public_function
+  id: user.relationship.get_follow_info
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk';
+ *
+ * let followInfo;
+ *
+ * const unsubscribe = UserRepository.Relationship.getFollowInfo(userId, response => {
+ *   followInfo = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.FollowCount} object
+ *
+ * @param userId the ID of the current user
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing
+ *
+ * @category FollowInfo Live Object
+ */
+export const getFollowInfo = (
+  userId: Amity.FollowInfo['userId'],
+  callback: Amity.LiveObjectCallback<Amity.FollowInfo>,
+): Amity.Unsubscriber => {
+  return liveObject(userId, callback, 'userId', _getFollowInfo, [onFollowInfoUpdated], {
+    forceDispatch: true,
+  });
+};
+/* end_public_function */

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, type: 'follower' });
+    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

@@ -0,0 +1,55 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { FollowerLiveCollectionController } from './getFollowers/FollowerLiveCollectionController';
+
+/* begin_public_function
+  id: user.relationship.query_my_followers, user.relationship.query_followers
+*/
+/**
+ * ```js
+ * import { getFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = getFollowers({
+ *   userId: Amity.InternalUser['userId'];
+ * }, response => merge(followers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followers for a given userId
+ *
+ * @param userId the user
+ * @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 messages
+ *
+ * @category Followers Live Collection
+ */
+export const getFollowers = (
+  params: Amity.FollowerLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getFollowers(tmpid: ${timestamp}) > listen`);
+
+  const followerLiveCollection = new FollowerLiveCollectionController(params, callback);
+  const disposers = followerLiveCollection.startSubscription();
+
+  const cacheKey = followerLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */