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

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

@@ -0,0 +1,239 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { queryFollowings } from '../../api/queryFollowings';
+import { getFollowings } from '../getFollowings';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow11,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('getFollowings', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { userId } = follows;
+  const args: Amity.FollowingLiveCollection = { 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 getFollowings check if mocked console get's called with the correct
+    // message
+    client.use();
+    getFollowings(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.page1 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowings(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);
+
+    getFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowings(args)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const statusFilters: [string, Amity.FollowingLiveCollection][] = [
+    ['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.page1 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowings(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 = queryFollowings(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.FollowingLiveCollection = { userId, limit: 3 };
+    const next = encodeJson({
+      limit: 3,
+      before: follows.page1[2].from,
+      updatedAt: follows.page1[2].updatedAt,
+    });
+
+    const response = { data: { follows: follows.page2, paging: {} } };
+    const responseWithNextPage = { data: { follows: follows.page1, paging: { next } } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(responseWithNextPage);
+
+    getFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryFollowings(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(queryFollowings(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 newFollowing: Amity.FollowStatus = {
+      ...follow11,
+      to: 'some-user',
+    };
+    const response = { data: { follows: follows.page1, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowings(args, callback);
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [newFollowing] });
+
+    snapshot.loading = false;
+    snapshot.data = [newFollowing, ...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.page1, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    getFollowings(args, callback);
+
+    await expect(queryFollowings(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));
+  });
+});

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

@@ -0,0 +1,197 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follow21,
+  follow11,
+  pause,
+  date,
+} from '~/utils/tests';
+
+import { getMyFollowInfo } from '../getMyFollowInfo';
+
+const FOLLOWING_COUNT = 2;
+const getMyFollowInfoMePayload = ({
+  userId = client.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('getMyFollowInfo > 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'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowMeStatusPayload('none'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowMeStatusPayload('none'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowMeStatusPayload('none'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({ data: getMyFollowInfoMePayload() })
+      .mockResolvedValueOnce({ data: payloadFrom })
+      .mockResolvedValueOnce({ data: payloadFrom });
+
+    const unsub = getMyFollowInfo(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('getMyFollowInfo > 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'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT + 1 }),
+    ],
+    [
+      'it should update follow info collection on unfollowed',
+      'follow.unfollowed',
+      getFollowStatusPayload('none'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+    [
+      'it should update follow info collection on requestDeclined',
+      'follow.requestDeclined',
+      getFollowStatusPayload('none'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT }),
+    ],
+    [
+      'it should update follow info collection on followerDeleted',
+      'follow.followerDeleted',
+      getFollowStatusPayload('none'),
+      getMyFollowInfoMePayload({ followingCount: FOLLOWING_COUNT - 1 }),
+    ],
+  ];
+
+  test.each(tests)('%s', async (description, event, payload, payloadFrom) => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({ data: getMyFollowInfoMePayload() })
+      .mockResolvedValueOnce({ data: payloadFrom })
+      .mockResolvedValueOnce({ data: payloadFrom });
+
+    const unsub = getMyFollowInfo(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/index.ts

@@ -0,0 +1,2 @@
+export * from './block';
+export * from './follow';

package/src/utils/constants.ts

@@ -0,0 +1,11 @@
+export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';
+export const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
+export const LIVE_OBJECT_ENABLE_CACHE_MESSAGE =
+  'For using Live Object feature you need to enable Cache!';
+export const UNSYNCED_OBJECT_CACHED_AT_MESSAGE =
+  'Observing unsynced object is not supported by Live Object.';
+export const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
+export const SECOND = 1000;
+export const MINUTE = 60 * SECOND;
+export const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;

package/src/utils/env.ts

@@ -0,0 +1,12 @@
+/* eslint-disable no-undef */
+const theGlobal =
+  // eslint-disable-next-line no-nested-ternary
+  typeof globalThis === 'object' ? globalThis : typeof global === 'object' ? global : window;
+
+export const { process: safeProcess = {} }: { process: Partial<NodeJS.Process> } = theGlobal;
+
+export function getEnv(): NodeJS.ProcessEnv | undefined {
+  return safeProcess.env ?? {};
+}
+
+export const isProduction = safeProcess.env?.NODE_ENV === 'production';

package/src/utils/event.ts

@@ -0,0 +1,25 @@
+import { pullFromCache } from '~/cache/api';
+
+export const convertEventPayload =
+  <
+    SourceModel extends Amity.Model,
+    DestinationDomain extends Amity.Domain,
+    DestinationModel extends Amity.Models[DestinationDomain],
+  >(
+    eventHandler: (callback: Amity.Listener<SourceModel>) => Amity.Unsubscriber,
+    sourceModelProp: keyof SourceModel,
+    destinationDomain: DestinationDomain,
+  ) =>
+  (callback: Amity.Listener<DestinationModel>) =>
+    eventHandler(sourceModel => {
+      if (!sourceModel) {
+        return sourceModel;
+      }
+
+      const cacheKey = [destinationDomain, 'get', `${sourceModel[sourceModelProp]}`];
+      const model = pullFromCache<DestinationModel>(cacheKey)?.data;
+
+      if (!model) return;
+
+      return callback(model);
+    });

package/src/utils/index.ts

@@ -0,0 +1,53 @@
+import { identifyModelKey } from '~/core/model';
+import { isEqual } from '~/utils/isEqual';
+
+export function hasMention(model: Amity.Mentionable<'user' | 'channel'>, userId: string) {
+  const channelMention = model?.mentionees?.find(x => x.type === 'channel') as Amity.ChannelMention;
+
+  if (channelMention) {
+    return true;
+  }
+
+  const userMention = model?.mentionees?.find(x => x.type === 'user') as Amity.UserMention;
+
+  if (userMention) {
+    return userMention.userIds.includes(userId);
+  }
+
+  return false;
+}
+
+export function shouldDispatchCollection<T extends Amity.Models[Amity.Domain] & Amity.UpdatedAt>(
+  collection: T[],
+  newItem: T,
+  action: 'onCreate' | string,
+): boolean {
+  const key = identifyModelKey(newItem);
+  // @ts-ignore
+  const item = collection.find(x => x[key] === newItem[key]);
+
+  if (item) {
+    return !isEqual(item, newItem);
+  }
+
+  return action === 'onCreate';
+}
+
+export function merge<T extends Amity.Models[Amity.Domain]>(
+  collection1: T[],
+  collection2: T[],
+): T[] {
+  const temp = [...collection1, ...collection2];
+
+  if (temp.length === 0) {
+    return [];
+  }
+
+  const key = identifyModelKey(temp[0]);
+  const map = new Map<string, T>();
+
+  // @ts-ignore
+  temp.forEach(x => map.set(x[key], x));
+
+  return Array.from(map.values());
+}

package/src/utils/inferIsDeleted.ts

@@ -0,0 +1,16 @@
+/*
+ * This is a simple utility that infers the value of isDeleted based on the
+ * value of includeDeleted
+ *
+ * There are two important things to note here:
+ *  1. `includeDeleted` is purely client side query param and not recognized by
+ *  the server
+ *  2. The only values we wish to expose with regards to `isDeleted` (the server
+ *  param for queries) is false | undefined and want to disallow users to query
+ *  for deleted entities
+ *
+ *  Although this is a very simple utility, it's only purpose is to keep things
+ *  DRY
+ */
+export const inferIsDeleted = (includeDeleted?: boolean): boolean | undefined =>
+  includeDeleted === true ? undefined : false;

package/src/utils/isEqual.ts

@@ -0,0 +1,69 @@
+/**
+ * ```js
+ * import { isEqual } from '~/utils/isEqual'
+ * const isEqual = isEqual(post1, post2)
+ * ```
+ *
+ * Compares two Amity.Model
+ *
+ * @param x the Amity.Model to compare
+ * @param y the Amity.Model to compare wit x
+ * @returns a boolean based on equality
+ *
+ * @category utility
+ * @private
+ */
+export function isEqual(x: any, y: any): boolean {
+  if (x === null || x === undefined || y === null || y === undefined) {
+    return x === y;
+  }
+
+  // after this just checking type of one would be enough
+  if (x.constructor !== y.constructor) {
+    return false;
+  }
+
+  // if they are functions, they should exactly refer to same one (because of closures)
+  if (x instanceof Function) {
+    return x === y;
+  }
+
+  // if they are regexps, they should exactly refer to same one
+  if (x instanceof RegExp) {
+    return x === y;
+  }
+
+  if (x === y || x.valueOf() === y.valueOf()) {
+    return true;
+  }
+
+  if (Array.isArray(x) && x.length !== y.length) {
+    return false;
+  }
+
+  // if they are dates, they must had equal valueOf
+  if (x instanceof Date) {
+    return false;
+  }
+
+  // if they are strictly equal, they both need to be object at least
+  if (!(x instanceof Object)) {
+    return false;
+  }
+
+  if (!(y instanceof Object)) {
+    return false;
+  }
+
+  // recursive object equality check
+  const p = Object.keys(x);
+  return (
+    Object.keys(y).every(i => {
+      // @ts-ignore
+      return p.indexOf(i) !== -1;
+    }) &&
+    p.every(i => {
+      return isEqual(x[i], y[i]);
+    })
+  );
+}