@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cbf10e4.0

package/src/follow/tests/observers/liveFollowers.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 { liveFollowers } from '../../observers/liveFollowers';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow21,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('liveFollowers', () => {
+  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 liveFollowers check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveFollowers(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);
+
+    liveFollowers(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);
+
+    liveFollowers(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);
+
+    liveFollowers(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);
+
+    liveFollowers(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);
+
+    liveFollowers(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);
+
+    liveFollowers(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));
+  });
+});

package/src/follow/tests/observers/liveFollowings.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 { liveFollowings } from '../../observers/liveFollowings';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow11,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('liveFollowings', () => {
+  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 liveFollowings check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveFollowings(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);
+
+    liveFollowings(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);
+
+    liveFollowings(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);
+
+    liveFollowings(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);
+
+    liveFollowings(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);
+
+    liveFollowings(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);
+
+    liveFollowings(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/group/utils/index.ts

@@ -0,0 +1 @@
+export * from './withUser';

package/src/group/utils/test/withUsers.test.ts

@@ -0,0 +1,103 @@
+import { disableCache, enableCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { withUser, withUsers } from '~/group/utils';
+import { baseMembership, user11, user12 } from '~/utils/tests';
+
+const users = [user11, user12];
+
+const member1: Amity.MembershipRaw<Amity.GroupType> = { ...baseMembership, userId: user11.userId };
+const mappedMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: user11 };
+const unmapableMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: undefined };
+
+const member2: Amity.MembershipRaw<Amity.GroupType> = { ...baseMembership, userId: user12.userId };
+const mappedMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: user12 };
+const unmapableMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: undefined };
+
+const members1: Amity.MembershipRaw<Amity.GroupType>[] = [member1, member2];
+const mappedMembers1: Amity.Membership<Amity.GroupType>[] = [mappedMember1, mappedMember2];
+const unmapableMembers1: Amity.Membership<Amity.GroupType>[] = [unmapableMember1, unmapableMember2];
+
+describe('withUser', () => {
+  test('should return mapped member', () => {
+    expect.assertions(2);
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUser(member1)).toEqual(mappedMember1);
+    expect(withUser(member2)).toEqual(mappedMember2);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(withUser(member1)).toEqual(unmapableMember1);
+  });
+
+  test('`.user` should return error member', () => {
+    expect.assertions(2);
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUser(member1)).toEqual(mappedMember1);
+    expect(withUser(member2)).toEqual(mappedMember2);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined when user not exist', () => {
+    enableCache();
+    ingestInCache({ users });
+    const member: Amity.MembershipRaw<Amity.GroupType> = {
+      ...member1,
+      userId: 'not-exist-user-id',
+    };
+    const expected: Amity.Membership<Amity.GroupType> = {
+      ...member,
+      user: undefined,
+    };
+
+    expect(withUser(member)).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('withUsers', () => {
+  test('should return mapped members', () => {
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUsers(members1)).toEqual(mappedMembers1);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(withUsers(members1)).toEqual(unmapableMembers1);
+  });
+
+  test('`.user` should return undefined when some user not exist', () => {
+    enableCache();
+    ingestInCache({ users });
+    const members: Amity.MembershipRaw<Amity.GroupType>[] = [
+      ...members1,
+      { ...member1, userId: 'not-exist-user-id' },
+    ];
+    const expected = [
+      ...mappedMembers1,
+      {
+        ...unmapableMember1,
+        userId: 'not-exist-user-id',
+        user: undefined,
+      },
+    ];
+
+    expect(withUsers(members)).toEqual(expected);
+
+    disableCache();
+  });
+});

package/src/group/utils/withUser.ts

@@ -0,0 +1,92 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+export const withUser = <
+  M extends Record<any, any>,
+  I extends keyof M = 'userId',
+  U extends string = 'user',
+>(
+  member: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): Record<U, Amity.User | undefined> & M => ({
+  get [userProp]() {
+    const client = getActiveClient();
+
+    if (!client.cache) return undefined;
+
+    const userCache = pullFromCache<Amity.User>(['user', 'get', member[userIdProp]])?.data;
+
+    if (!userCache) {
+      return undefined;
+    }
+
+    return userCache;
+  },
+  ...member,
+});
+
+/**
+ * Mapping membership model with user object
+ *
+ * @param members The membership model objects
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model objects that is already
+ * mapped to users
+ * @hidden
+ */
+export const withUsers = <
+  M extends Record<any, any>[],
+  I extends keyof M[number] = 'userId',
+  U extends string = 'user',
+>(
+  members: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): (Record<U, Amity.User | undefined> & M[number])[] =>
+  members.map(member => withUser(member, userIdProp, userProp));
+
+/**
+ * Transform members prop in any payload with attached users members
+ *
+ * @param payload The payload contain members prop
+ * @param memberProp A name of members prop
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The transforming payload
+ * @hidden
+ */
+export const prepareMembershipPayload = <
+  P extends Record<any, any>,
+  M extends keyof P,
+  I extends keyof P[M][number] = 'userId',
+  U extends string = 'user',
+>(
+  payload: P,
+  memberProp: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): Omit<P, M> & Record<M, (Record<U, Amity.User | undefined> & P[M][number])[]> => {
+  const { [memberProp]: memberPayload, ...rest } = payload;
+  const members = withUsers(memberPayload, userIdProp, userProp);
+
+  return {
+    ...rest,
+    ...{ [memberProp]: members },
+  };
+};

package/src/index.ts

@@ -1,5 +1,5 @@
 // types
-import './@types';
+export * from './@types';
 
 export * from './version';
 
@@ -25,6 +25,7 @@ export * from './role/api';
 // // asc partials
 export * from './reaction/api';
 export * from './reaction/events';
+export * from './reaction/observers';
 
 export * from './report/api';
 
@@ -33,6 +34,10 @@ export * from './channel/api';
 export * from './channel/events';
 export * from './channel/observers';
 
+export * from './subChannel/api';
+export * from './subChannel/events';
+export * from './subChannel/observers';
+
 export * from './message/api';
 export * from './message/events';
 export * from './message/observers';
@@ -59,6 +64,8 @@ export * from './comment/events';
 export * from './comment/observers';
 
 export * from './poll/api';
+export * from './poll/events';
+export * from './poll/observers';
 
 export * from './stream/api';
 export * from './stream/events';