@amityco/ts-sdk 0.0.1-003998f.0

package/src/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/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/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/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/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/follow/events/utils.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { queryCache, upsertInCache } from '~/cache/api';
+
+export const createFollowEventSubscriber = (
+  event: keyof Amity.MqttFollowMessageEvents,
+  callback: Amity.Listener<Amity.FollowStatus>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.FollowersPayload | Amity.FollowStatusPayload) => {
+    if (!client.cache) {
+      callback(payload.follows[0]);
+    } else {
+      ingestInCache(payload);
+
+      const queries = [
+        ...(queryCache(['followers', 'query']) ?? []),
+        ...(queryCache(['followings', 'query']) ?? []),
+      ];
+
+      queries
+        .filter(
+          ({ key }) =>
+            // @ts-ignore
+            key[2].userId === payload.follows[0].from || key[2].userId === payload.follows[0].to,
+        )
+        .forEach(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
+
+      callback(payload.follows[0]);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/follow/observers/index.ts

@@ -0,0 +1,6 @@
+export * from './observeFollowInfo';
+export * from './observeFollowers';
+export * from './observeFollowings';
+
+export * from './liveFollowers';
+export * from './liveFollowings';

package/src/follow/observers/liveFollowers.ts

@@ -0,0 +1,149 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions, filterByPropEquality } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+import { queryFollowers } from '../api';
+
+/**
+ * ```js
+ * import { liveFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = liveFollowers({
+ *   userId: Amity.User['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 liveFollowers = (
+  params: Amity.FollowerLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveFollowers(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 = ['follow', 'collection', { userId: params.userId, type: 'follower' }];
+
+  const responder = (data: Amity.FollowerLiveCollectionCache) => {
+    let followers: Amity.FollowStatus[] =
+      data.data
+        .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.status && params.status !== 'all') {
+      followers = filterByPropEquality(followers, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.userId !== followStatus.to || !collection) return;
+
+    if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+    } else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+      collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.FollowerLiveCollectionCache>(cacheKey)?.data;
+
+    const followers = collection?.data ?? [];
+
+    if (followers.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryFollowers, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: followers,
+        };
+
+        if (result) {
+          data.data = [...new Set([...followers, ...result.map(getResolver('follow'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
+    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
+    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
+    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
+    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
+    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
+    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/liveFollowings.ts

@@ -0,0 +1,149 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { createQuery, runQuery, queryOptions, filterByPropEquality } from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+import { queryFollowings } from '../api';
+
+/**
+ * ```js
+ * import { liveFollowings } from '@amityco/ts-sdk'
+ *
+ * let followings = []
+ * const unsub = liveFollowings({
+ *   userId: Amity.User['userId'];
+ * }, response => merge(followings, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.FollowStatus} followings 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 Followings Live Collection
+ */
+export const liveFollowings = (
+  params: Amity.FollowingLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.FollowStatus>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveFollowings(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 = ['follow', 'collection', { userId: params.userId, type: 'following' }];
+
+  const responder = (data: Amity.FollowingLiveCollectionCache) => {
+    let followings: Amity.FollowStatus[] =
+      data.data
+        .map(key => pullFromCache<Amity.FollowStatus>(['follow', 'get', key])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    if (params.status && params.status !== 'all') {
+      followings = filterByPropEquality(followings, 'status', params.status);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: followings,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (followStatus: Amity.FollowStatus, action: Amity.FollowActionType) => {
+    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
+
+    if (params.userId !== followStatus.from || !collection) return;
+
+    if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
+      collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+    } else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
+      collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.FollowingLiveCollectionCache>(cacheKey)?.data;
+
+    const followings = collection?.data ?? [];
+
+    if (followings.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryFollowings, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: followings,
+        };
+
+        if (result) {
+          data.data = [...new Set([...followings, ...result.map(getResolver('follow'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onFollowerRequested(followStatus => realtimeRouter(followStatus, 'onRequested')),
+    onFollowRequestAccepted(followStatus => realtimeRouter(followStatus, 'onAccepted')),
+    onFollowRequestDeclined(followStatus => realtimeRouter(followStatus, 'onDeclined')),
+    onFollowRequestCanceled(followStatus => realtimeRouter(followStatus, 'onCanceled')),
+    onUserFollowed(followStatus => realtimeRouter(followStatus, 'onFollowed')),
+    onUserUnfollowed(followStatus => realtimeRouter(followStatus, 'onUnfollowed')),
+    onFollowerDeleted(followStatus => realtimeRouter(followStatus, 'onDeleted')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveFollowings(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/observeFollowInfo.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { getFollowInfo } from '../api';
+import { onFollowInfoUpdated } from '../events';
+
+/**
+ * ```js
+ * import { observeFollowInfo } from '@amityco/ts-sdk'
+ *
+ * let followInfo = {}
+ * const dispose = observeFollowInfo(userId, updated => followInfo = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.FollowInfo}
+ *
+ * @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 post
+ *
+ * @category Follow Observer
+ */
+export const observeFollowInfo = <Events extends ['onFetch', 'onUpdate']>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.FollowInfo>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFollowInfo(tmpid: ${timestamp}) > listen`);
+
+  const router = (result: Amity.Snapshot<Amity.FollowInfo>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const realtimeRouter = (result: Amity.Snapshot<Amity.FollowInfo>, action: Events[number]) => {
+    if (result.data?.userId !== userId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onFollowInfoUpdated(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+  );
+
+  runQuery(
+    createQuery(getFollowInfo, userId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
+
+  return () => {
+    log(`observeFollowInfo(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/observeFollowers.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeFollowers } from '@amityco/ts-sdk'
+ *
+ * let followers = []
+ * const unsub = observeFollowers('userId', follower => merge(followers, follower))
+ * ```
+ *
+ * Observe all mutations on a list of followers {@link Amity.FollowStatus} for a given user
+ *
+ * @param userId the ID of the {@link Amity.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 Follow Observer
+ */
+export const observeFollowers = <
+  Events extends [
+    'onRequested',
+    'onAccepted',
+    'onDeclined',
+    'onCanceled',
+    'onFollowed',
+    'onUnfollowed',
+    'onDeleted',
+  ],
+>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFollowers(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (status: Amity.FollowStatus, action: Events[number]) => {
+    if (status.from !== userId) {
+      return;
+    }
+
+    if (callback instanceof Function) {
+      return callback(status);
+    }
+
+    callback.onEvent?.(action, status);
+    callback[action]?.(status);
+  };
+
+  disposers.push(
+    onFollowerRequested(x => router(x, 'onRequested')),
+    onFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onFollowRequestCanceled(x => router(x, 'onCanceled')),
+    onUserFollowed(x => router(x, 'onFollowed')),
+    onUserUnfollowed(x => router(x, 'onUnfollowed')),
+    onFollowerDeleted(x => router(x, 'onDeleted')),
+  );
+
+  return () => {
+    log(`observeFollowers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/follow/observers/observeFollowings.ts

@@ -0,0 +1,77 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onFollowerRequested,
+  onFollowRequestAccepted,
+  onFollowRequestDeclined,
+  onFollowRequestCanceled,
+  onUserFollowed,
+  onUserUnfollowed,
+  onFollowerDeleted,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeFollowings } from '@amityco/ts-sdk'
+ *
+ * let followings = []
+ * const unsub = observeFollowers('userId', follower => merge(followings, following))
+ * ```
+ *
+ * Observe all mutations on a list of followings {@link Amity.FollowStatus} for a given user
+ *
+ * @param userId the ID of the {@link Amity.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 Follow Observer
+ */
+export const observeFollowings = <
+  Events extends [
+    'onRequested',
+    'onAccepted',
+    'onDeclined',
+    'onCanceled',
+    'onFollowed',
+    'onUnfollowed',
+    'onDeleted',
+  ],
+>(
+  userId: Amity.User['userId'],
+  callback: Amity.ObjectListener<Amity.FollowStatus, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeFollowings(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (status: Amity.FollowStatus, action: Events[number]) => {
+    if (status.to !== userId) {
+      return;
+    }
+
+    if (callback instanceof Function) {
+      return callback(status);
+    }
+
+    callback.onEvent?.(action, status);
+    callback[action]?.(status);
+  };
+
+  disposers.push(
+    onFollowerRequested(x => router(x, 'onRequested')),
+    onFollowRequestAccepted(x => router(x, 'onAccepted')),
+    onFollowRequestDeclined(x => router(x, 'onDeclined')),
+    onFollowRequestCanceled(x => router(x, 'onCanceled')),
+    onUserFollowed(x => router(x, 'onFollowed')),
+    onUserUnfollowed(x => router(x, 'onUnfollowed')),
+    onFollowerDeleted(x => router(x, 'onDeleted')),
+  );
+
+  return () => {
+    log(`observeFollowings(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};