@amityco/ts-sdk-react-native 6.7.1-80c1951.0

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

@@ -0,0 +1,39 @@
+import { getActiveUser } from '~/client';
+import { liveObject } from '~/utils/liveObject';
+import { getFollowInfo as _getFollowInfo } from '../api/getFollowInfo';
+import { onFollowInfoUpdated } from '../events';
+
+/* begin_public_function
+  id: user.relationship.get_my_follow_info
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk-react-native';
+ *
+ * let myFollowInfo;
+ *
+ * const unsubscribe = UserRepository.Relationship.getMyFollowInfo(response => {
+ *   myFollowInfo = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on the current users {@link Amity.FollowCount} object
+ *
+ * @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 getMyFollowInfo = (
+  callback: Amity.LiveObjectCallback<Amity.FollowInfo>,
+): Amity.Unsubscriber => {
+  const { userId } = getActiveUser();
+
+  return liveObject(userId, callback, 'userId', _getFollowInfo, [onFollowInfoUpdated], {
+    /*
+     * Required as Amity.FollowInfo does not extend Amity.Timestamps
+     */
+    forceDispatch: true,
+  });
+};
+/* end_public_function */

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

@@ -0,0 +1,8 @@
+export * from './observeFollowInfo';
+export * from './observeFollowers';
+export * from './observeFollowings';
+
+export * from './getFollowers';
+export * from './getFollowings';
+export * from './getFollowInfo';
+export * from './getMyFollowInfo';

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

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+import { getFollowInfo } from '../api/getFollowInfo';
+import { onFollowInfoUpdated } from '../events';
+
+/**
+ * ```js
+ * import { observeFollowInfo } from '@amityco/ts-sdk-react-native'
+ *
+ * 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/userRepository/relationship/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-react-native'
+ *
+ * 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/userRepository/relationship/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-react-native'
+ *
+ * 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());
+  };
+};

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

@@ -0,0 +1,197 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follow21,
+  follow11,
+  user11,
+  pause,
+  date,
+} from '~/utils/tests';
+
+import { getFollowInfo } from '../getFollowInfo';
+
+const FOLLOWING_COUNT = 2;
+const getFollowInfoMePayload = ({
+  userId = user11.userId,
+  followerCount = 0,
+  pendingCount = 0,
+  followingCount = FOLLOWING_COUNT,
+} = {}): Amity.FollowInfoMePayload => {
+  return {
+    followCounts: [
+      {
+        userId,
+        followerCount,
+        pendingCount,
+        followingCount,
+      },
+    ],
+  };
+};
+
+const getFollowMeStatusPayload = (
+  status: Amity.FollowStatus['status'] = follow11.status,
+): Amity.FollowStatusPayload => {
+  return {
+    follows: [
+      {
+        from: follow11.from,
+        to: follow11.to,
+        status,
+        createdAt: date,
+        updatedAt: date,
+      },
+    ],
+  };
+};
+
+const getFollowStatusPayload = (
+  status: Amity.FollowStatus['status'] = follow21.status,
+): Amity.FollowStatusPayload => {
+  return {
+    follows: [
+      {
+        from: follow21.from,
+        to: follow21.to,
+        status,
+        createdAt: date,
+        updatedAt: date,
+      },
+    ],
+  };
+};
+
+describe('getFollowInfo > me', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const tests: [
+    string,
+    keyof Amity.MqttFollowEvents,
+    Amity.FollowStatusPayload,
+    Amity.FollowInfoMePayload,
+  ][] = [
+    [
+      'it should update follow info collection on accepted',
+      'follow.accepted',
+      getFollowMeStatusPayload('accepted'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowMeStatusPayload('none'),
+      getFollowInfoMePayload({ userId: user11.userId, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+
+    client.http.get = jest
+      .fn()
+      .mockResolvedValueOnce({ data: getFollowInfoMePayload() })
+      .mockResolvedValue({ data: payloadFrom });
+
+    const unsub = getFollowInfo(user11.userId, callback);
+    await pause();
+
+    client.emitter.emit(event, payload);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: payloadFrom.followCounts[0],
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+});
+
+describe('getFollowInfo > other', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const tests: [
+    string,
+    keyof Amity.MqttFollowEvents,
+    Amity.FollowStatusPayload,
+    Amity.FollowInfoMePayload,
+  ][] = [
+    [
+      'it should update follow info collection on accepted',
+      'follow.accepted',
+      getFollowStatusPayload('accepted'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowStatusPayload('none'),
+      getFollowInfoMePayload({ userId: follow21.from, followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValueOnce({ data: getFollowInfoMePayload({ userId: follow21.from }) })
+      .mockResolvedValue({ data: payloadFrom });
+
+    const unsub = getFollowInfo(follow21.from, callback);
+    await pause();
+
+    client.emitter.emit(event, payload);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: payloadFrom.followCounts[0],
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+});

package/src/userRepository/relationship/follow/observers/tests/getFollowers.test.ts

@@ -0,0 +1,240 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { queryFollowers } from '../../api/queryFollowers';
+import { getFollowers } from '../getFollowers';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow21,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('getFollowers', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { userId } = follows;
+  const args: Amity.FollowerLiveCollection = { userId };
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is diabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+
+    const callback = jest.fn();
+    jest.spyOn(global.console, 'log');
+    client.http.get = jest.fn();
+
+    // call getFollowers check if mocked console get's called with the correct
+    // message
+    client.use();
+    getFollowers(args, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return following collection', async () => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page2 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowers(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = response.data.follows;
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return error on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    getFollowers(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowers(args)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const statusFilters: [string, Amity.FollowerLiveCollection][] = [
+    ['all', { ...args, status: 'all', limit: 10 }],
+    ['accepted', { ...args, status: 'accepted', limit: 10 }],
+    ['pending', { ...args, status: 'pending', limit: 10 }],
+  ];
+
+  test.each(statusFilters)('it should filter %s follows based on param', async (filter, params) => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page2 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowers(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    // TODO : why ts gives no shit about args here ? wrong type :D
+    const query = queryFollowers(params);
+
+    await expect(query).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data =
+      filter === 'all'
+        ? response.data.follows
+        : response.data.follows.filter(fl => fl.status === filter);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const snapshot = getSnapshot();
+    const args: Amity.FollowerLiveCollection = { userId, limit: 3 };
+    const next = encodeJson({
+      limit: 3,
+      before: follows.page2[2].from,
+      updatedAt: follows.page2[2].updatedAt,
+    });
+
+    const response = { data: { follows: follows.page1, paging: {} } };
+    const responseWithNextPage = { data: { follows: follows.page2, paging: { next } } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(responseWithNextPage);
+
+    getFollowers(args, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    onNextPage();
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    snapshot.loading = false;
+    snapshot.data = [...responseWithNextPage.data.follows, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const createEvents: [keyof Amity.Events][] = [
+    ['follow.created'],
+    ['follow.requested'],
+    ['follow.accepted'],
+  ];
+
+  test.each(createEvents)('it should add new follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const newFollower: Amity.FollowStatus = {
+      ...follow21,
+      from: 'some-user',
+    };
+    const response = { data: { follows: follows.page2, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowers(args, callback);
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [newFollower] });
+
+    snapshot.loading = false;
+    snapshot.data = [newFollower, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const removeEvents: [keyof Amity.Events][] = [
+    ['follow.requestDeclined'],
+    ['follow.requestCanceled'],
+    ['follow.unfollowed'],
+    ['follow.followerDeleted'],
+  ];
+
+  test.each(removeEvents)('it should remove a follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const response = { data: { follows: follows.page2, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowers(args, callback);
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [response.data.follows[0]] });
+
+    const [first, ...data] = response.data.follows;
+
+    snapshot.data = data;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});