@amityco/ts-sdk 0.0.1-beta → 0.0.1-beta-34

package/src/user/tests/observers/liveUser.test.ts

@@ -0,0 +1,224 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { liveUser } from '../../observers/liveUser';
+
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  userQueryResponse,
+  user11 as defaultUser,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: undefined as undefined | Amity.User,
+  };
+};
+
+describe('liveUser', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  test('it should show user 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 liveUser check if mocked console get's called with the correct
+    // user
+    client.use();
+    liveUser(defaultUser.userId, callback);
+
+    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return user live object', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = defaultUser;
+
+    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,
+    );
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should terminate updates on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+
+    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedUser = {
+      ...defaultUser,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedUser;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should not return updates on obtain once!', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    const unsub = liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    unsub();
+
+    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedUser = {
+      ...defaultUser,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedUser;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events][] = [
+    ['it should return updated user on onFetch', 'user.fetched'],
+    ['it should return updated user on onUpdate', 'user.updated'],
+    ['it should return updated user on onDelete', 'user.deleted'],
+    ['it should return updated user on onFlagged', 'user.flagged'],
+    ['it should return updated user on onUnflagged', 'user.unflagged'],
+    ['it should return updated user on onFlagCleared', 'user.flagCleared'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUser(defaultUser.userId, callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedUser = {
+      ...defaultUser,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit(event, { users: [updatedUser], files: [] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedUser;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/utils/constants.ts

@@ -0,0 +1,8 @@
+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;

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/tests/client.ts

@@ -0,0 +1,33 @@
+import {
+  createClient,
+  connectClient as sdkConnectClient,
+  disconnectClient as sdkDisconnectClient,
+} from '~/client/api';
+
+import { user11 } from './dummy';
+
+export const client = createClient('key', 'sg');
+
+export const connectClient = async () => {
+  client.mqtt.connect = jest.fn();
+  client.mqtt.subscribe = jest.fn();
+  client.http.post = jest.fn().mockReturnValueOnce({
+    data: {
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+      users: [user11],
+    },
+  });
+
+  setTimeout(() => {
+    client.ws.emit('connect');
+  }, 500);
+
+  await sdkConnectClient({ userId: 'test' });
+};
+
+export const disconnectClient = async () => {
+  sdkDisconnectClient().then(() => client.ws.emit('disconnect'));
+};
+
+export default {};

package/src/utils/tests/dummy/channel.ts

@@ -0,0 +1,200 @@
+import { date, rolesAndPermissions, user11, user12, user13, user14, file11 } from '.';
+
+const mockPage = {
+  paging: {
+    previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  },
+};
+
+export const channelRaw1: Amity.ChannelRaw = {
+  tags: ['tag2'],
+  messageCount: 1,
+  createdAt: date,
+  isDeleted: false,
+  type: 'community',
+  channelId: 'channelId11',
+};
+
+export const channelRaw2: Amity.ChannelRaw = {
+  tags: ['tag1'],
+  messageCount: 3,
+  createdAt: date,
+  isDeleted: true,
+  type: 'conversation',
+  channelId: 'channelId12',
+};
+
+export const channelRaw3: Amity.ChannelRaw = {
+  messageCount: 3,
+  createdAt: date,
+  type: 'community',
+  channelId: 'channelId21',
+};
+
+export const channel11: Amity.Channel = {
+  ...channelRaw1,
+  hasMention: false,
+  unreadCount: 0,
+  type: 'community',
+};
+
+export const channel12: Amity.Channel = {
+  ...channelRaw2,
+  hasMention: true,
+  unreadCount: 2,
+};
+
+export const channel21: Amity.Channel = {
+  ...channelRaw3,
+  hasMention: false,
+  unreadCount: 0,
+  type: 'conversation',
+  isDeleted: true,
+  tags: ['tag1'],
+};
+
+export const channelUser1: Amity.MembershipRaw<'channel'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: false,
+  readToSegment: 1,
+  lastActivity: date,
+  membership: 'member',
+  userId: user11.userId,
+  ...rolesAndPermissions,
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser2: Amity.MembershipRaw<'channel'> = {
+  ...channelUser1,
+  readToSegment: 1,
+  lastMentionedSegment: 2,
+  channelId: channel12.channelId,
+};
+
+export const channelUser3: Amity.MembershipRaw<'channel'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: false,
+  readToSegment: 1,
+  lastActivity: date,
+  userId: user12.userId,
+  ...rolesAndPermissions,
+  membership: 'none',
+  roles: ['test-role'],
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser4: Amity.MembershipRaw<'channel'> = {
+  ...channelUser3,
+  userId: user13.userId,
+};
+
+export const channelUser5: Amity.MembershipRaw<'channel'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: true,
+  readToSegment: 1,
+  lastActivity: date,
+  userId: user13.userId,
+  ...rolesAndPermissions,
+  membership: 'banned',
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser6: Amity.MembershipRaw<'channel'> = {
+  isMuted: true,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: true,
+  readToSegment: 1,
+  lastActivity: date,
+  userId: 'test',
+  ...rolesAndPermissions,
+  membership: 'banned',
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser7: Amity.MembershipRaw<'channel'> = {
+  ...channelUser3,
+  membership: 'member',
+  userId: user14.userId,
+};
+
+export const channelQueryResponse = {
+  data: {
+    channels: [channel11, channel12],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelQueryResponsePage2 = {
+  data: {
+    channels: [channel21],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserQueryResponse = {
+  data: {
+    channels: [channel11],
+    channelUsers: [channelUser1, channelUser3],
+    users: [user11, user12],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserModel = [
+  { ...channelUser1, user: user11 },
+  { ...channelUser3, user: user12 },
+];
+
+export const channelUserQueryResponsePage2 = {
+  data: {
+    channels: [channel11],
+    channelUsers: [channelUser4],
+    users: [user13],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserModel2 = [{ ...channelUser4, user: user13 }];
+
+export const channelUserQueryResponsePage3 = {
+  data: {
+    channels: [channel11],
+    channelUsers: [channelUser7, channelUser6],
+    users: [user11, user14],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserModel3 = [
+  { ...channelUser7, user: user14 },
+  { ...channelUser6, user: user11 },
+];
+
+// for testing ingest in cache
+export const channelPayload = {
+  channels: [channel11],
+  channelUsers: [channelUser7, channelUser6],
+  users: [user14, user11],
+  files: [file11],
+};

package/src/utils/tests/dummy/community.ts

@@ -0,0 +1,92 @@
+import { baseMembership, date, user11, user12, file11 } from '.';
+
+const mockPage: Amity.Pagination = {
+  paging: {
+    previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  },
+};
+
+export const baseCommunity: Amity.Community = {
+  categoryIds: [],
+  channelId: '',
+  communityId: '',
+  createdAt: '',
+  displayName: '',
+  hasFlaggedComment: false,
+  hasFlaggedPost: false,
+  membersCount: 0,
+  path: '',
+  postsCount: 0,
+  userId: '',
+};
+
+export const community11: Amity.Community = {
+  ...baseCommunity,
+  isOfficial: false,
+  isPublic: true,
+  postsCount: 7,
+  membersCount: 1,
+  updatedAt: '2022-10-31T05:06:57.999Z',
+  createdAt: '2022-10-31T02:48:34.978Z',
+  isDeleted: false,
+  displayName: 'HardDelete1',
+  tags: [],
+  metadata: {},
+  hasFlaggedComment: false,
+  hasFlaggedPost: true,
+  communityId: 'community11',
+  channelId: '635f3782064bf304f786707d',
+  userId: user11.userId,
+  isJoined: false,
+  avatarFileId: undefined,
+  categoryIds: [],
+};
+
+export const communityUser11: Amity.MembershipRaw<'community'> = {
+  ...baseMembership,
+  communityMembership: 'member',
+  lastActivity: '2022-10-25T11:10:13.048Z',
+  updatedAt: '2022-10-25T11:10:13.048Z',
+  createdAt: '2022-10-25T11:10:13.048Z',
+  muteTimeout: '2022-10-25T11:10:13.048Z',
+  isMuted: false,
+  isBanned: false,
+  userId: 'test',
+  communityId: community11.communityId,
+  roles: ['channel-moderator', 'community-moderator'],
+  permissions: [Amity.Permission.CreateRolePermission],
+};
+
+export const communityUser12: Amity.MembershipRaw<'community'> = {
+  ...baseMembership,
+  createdAt: date,
+  lastActivity: date,
+  userId: user12.userId,
+  communityId: community11.communityId,
+  communityMembership: 'member',
+};
+
+export const communityPayload: Amity.CommunityPayload = {
+  communities: [community11],
+  communityUsers: [communityUser11],
+  files: [file11],
+  users: [user11],
+};
+
+export const communityUserQueryResponse = {
+  data: {
+    communities: [community11],
+    communityUsers: [communityUser11, communityUser12],
+    users: [user11, user12],
+    files: [],
+    categories: [],
+    feeds: [],
+    ...mockPage,
+  },
+};
+
+export const communityUserModel = [
+  { ...communityUser11, user: user11 },
+  { ...communityUser12, user: user12 },
+];

package/src/utils/tests/dummy/file.ts

@@ -0,0 +1,20 @@
+export const file11: Amity.File<'image'> = {
+  fileId: 'file-Id',
+  fileUrl: 'https://fileUrl.com/test-file',
+  type: 'image',
+  createdAt: '2022-10-28T08:01:51.996Z',
+  updatedAt: '2022-10-28T08:01:51.996Z',
+  attributes: {
+    name: 'test.png',
+    extension: 'png',
+    size: '166904',
+    mimeType: 'image/png',
+    metadata: {
+      height: 966,
+      width: 1918,
+      isFull: false,
+      exif: {},
+      gps: {},
+    },
+  },
+};

package/src/utils/tests/dummy/follow.ts

@@ -0,0 +1,66 @@
+import { date, user11, user12, user13, user14 } from '.';
+
+const timeStamps: Amity.Timestamps = {
+  createdAt: date,
+  updatedAt: date,
+};
+
+// user11 follows user12
+export const follow11: Amity.FollowStatus = {
+  ...timeStamps,
+  to: user12.userId,
+  status: 'accepted',
+  from: user11.userId,
+};
+
+// user11 pineding user13
+export const follow12: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'pending',
+  to: user13.userId,
+  from: user11.userId,
+};
+
+// user14 declined user11
+export const follow13: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'none',
+  to: user14.userId,
+  from: user11.userId,
+};
+
+// user12 follows user11
+export const follow21: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'accepted',
+  to: user11.userId,
+  from: user12.userId,
+};
+
+// user13 pineding user11
+export const follow22: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'pending',
+  to: user11.userId,
+  from: user13.userId,
+};
+
+// user11 declined user14
+export const follow23: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'none',
+  to: user11.userId,
+  from: user14.userId,
+};
+
+export const follows = {
+  userId: user11.userId,
+  page1: [follow11, follow12, follow13],
+  page2: [follow21, follow22, follow23],
+};
+
+export const followPayload: Amity.FollowersPayload = {
+  users: [user11, user12],
+  files: [],
+  follows: [follow11, follow12],
+};

package/src/utils/tests/dummy/index.ts

@@ -0,0 +1,19 @@
+export const date = new Date().toISOString();
+export const rolesAndPermissions = { roles: [], permissions: [] };
+
+export * from './user';
+export * from './role';
+export * from './file';
+
+export * from './post';
+
+export * from './poll';
+export * from './follow';
+export * from './reaction';
+
+export * from './channel';
+export * from './community';
+
+export * from './message';
+export * from './member';
+export * from './community';

package/src/utils/tests/dummy/member.ts

@@ -0,0 +1,18 @@
+import { rolesAndPermissions } from '.';
+
+export const baseMembership: Amity.MembershipRaw<Amity.GroupType> = {
+  channelId: '',
+  communityId: '',
+  communityMembership: 'member',
+  createdAt: '',
+  isBanned: false,
+  isMuted: false,
+  lastActivity: '',
+  lastMentionedSegment: 0,
+  membership: 'member',
+  muteTimeout: '',
+  readToSegment: 0,
+  updatedAt: '',
+  userId: '',
+  ...rolesAndPermissions,
+};