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

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

@@ -0,0 +1,204 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  user11,
+  user12,
+  user21,
+  userQueryResponse,
+  userQueryResponsePage2,
+} from '~/utils/tests';
+
+import { liveUsers } from '../liveUsers';
+
+const getSnapshot = (params?: Record<string, any>) => {
+  return {
+    data: [] as Amity.User[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+const { paging, ...payload } = userQueryResponse.data;
+const { paging: paging2, ...payload2 } = userQueryResponsePage2.data;
+
+describe('liveUsers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const params = { sortBy: 'lastCreated' } as Amity.UserLiveCollection;
+
+  // integration_test_id: c7cb9776-5c72-4abe-9b3c-572d74d534fe
+  test('it should return users collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUsers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.users,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return data from cache', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUsers(params, () => undefined);
+    await pause();
+    liveUsers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.users,
+        }),
+      ),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(
+        getSnapshot({
+          data: payload.users,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(userQueryResponse)
+      .mockResolvedValueOnce(userQueryResponsePage2);
+
+    liveUsers(params, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    // 4 -> because 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: [...payload2.users, ...payload.users],
+        }),
+      ),
+    );
+  });
+
+  describe('events', () => {
+    const updatedUser = { ...user11, displayName: 'updated-user' };
+    const flaggedUser = { ...user11, flagCount: 1 };
+    const unflaggedUser = { ...user11, flagCount: 1 };
+    const flagClearedUser = { ...user11, flagCount: 0 };
+
+    const cases: [string, keyof Amity.Events, Amity.UserPayload, Amity.User[]][] = [
+      [
+        'it should update user in collection onUpdate',
+        'user.updated',
+        { users: [updatedUser], files: [] },
+        [updatedUser, user12],
+      ],
+      [
+        'it should update user in collection onUpdate',
+        'user.flagged',
+        { users: [flaggedUser], files: [] },
+        [flaggedUser, user12],
+      ],
+      [
+        'it should update user in collection onUpdate',
+        'user.unflagged',
+        { users: [unflaggedUser], files: [] },
+        [unflaggedUser, user12],
+      ],
+      [
+        'it should update user in collection onUpdate',
+        'user.flagCleared',
+        { users: [flagClearedUser], files: [] },
+        [flagClearedUser, user12],
+      ],
+    ];
+
+    test.each(cases)('%s', async (test, event, user, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+      liveUsers(params, callback);
+      await pause();
+
+      client.emitter.emit(event, user);
+      await pause();
+
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining(
+          getSnapshot({
+            data: expected,
+            loading: false,
+          }),
+        ),
+      );
+    });
+  });
+
+  // integration_test_id: 60b4b354-efca-49bc-aa8b-d63a8da6ef31
+  const filters: [string, Amity.UserLiveCollection, Amity.User[]][] = [
+    ['displayName', { displayName: 'displayName' }, [user21]],
+  ];
+
+  test.each(filters)('it should filter by %s communities', async (filter, params, expected) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponsePage2);
+
+    liveUsers(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining(
+        getSnapshot({
+          loading: false,
+          data: expected,
+        }),
+      ),
+    );
+  });
+});

package/src/user/tests/api/getUser.test.ts

@@ -0,0 +1,126 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { client, user11 } from '~/utils/tests';
+
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+
+import { getUser } from '../../api/getUser';
+
+const user = user11;
+const getResolvedUserValue = () => ({
+  data: {
+    users: [user],
+    files: [],
+  },
+});
+
+describe('getUser', () => {
+  // integration_test_id: c9d28b37-c761-4df5-ac86-060a506f3007
+  test('should return user data', async () => {
+    client.http.get = jest.fn().mockResolvedValue(getResolvedUserValue());
+
+    const { data } = await getUser(user.userId);
+
+    expect(data).toStrictEqual(user);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedUserValue());
+    await getUser(user.userId);
+
+    expect(getUser.locally(user.userId)).toBeDefined();
+
+    disableCache();
+  });
+
+  // integration_test_id: b5204e28-7e11-44ff-b391-48181f1822ba
+  test('should return an error', async () => {
+    const expected = new ASCApiError(
+      'User not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValue({
+      data: expected,
+    });
+
+    try {
+      await getUser(user.userId);
+    } catch ({ data = null }) {
+      expect(data).toEqual(expected);
+    }
+  });
+
+  test('should return an error if user in cache but api throws not found', async () => {
+    enableCache();
+    pushToCache(['user', 'get', user.userId], user, { cachedAt: Date.now() });
+
+    client.http.get = jest
+
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getUser(user.userId)).rejects.toThrow();
+
+    expect(getUser.locally(user.userId)).toBeUndefined();
+    disableCache();
+  });
+});
+
+describe('getUser locally', () => {
+  test('should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['user', 'get', user.userId], user, { cachedAt });
+
+    const data = getUser.locally(user.userId);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(user);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if user not in cache', () => {
+    expect(getUser.locally('non-existent-user')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getUser.locally(user.userId)).toBeUndefined();
+  });
+});
+
+describe('getUser tombostone', () => {
+  test('it should add user to tombostone if 404', async () => {
+    enableCache();
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getUser(user.userId)).rejects.toThrow();
+    expect(() => {
+      isInTombstone('user', user.userId);
+    }).toThrow();
+
+    disableCache();
+  });
+
+  test('it should throw error if user not found in tombostone', async () => {
+    enableCache();
+
+    pushToTombstone('user', user.userId);
+    await expect(getUser(user.userId)).rejects.toThrow();
+
+    disableCache();
+  });
+});

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

@@ -0,0 +1,67 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  user11 as defaultUser,
+  userQueryResponse,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+import { liveUser } from '../../observers/liveUser';
+
+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(enableCache);
+
+  afterEach(disableCache);
+
+  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 updatedUser = {
+      ...defaultUser,
+      updatedAt: getFutureDate(defaultUser.updatedAt),
+    };
+    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,10 @@
+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 MINUTE = 60 * 1000;
+export const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;

package/src/utils/index.ts

@@ -0,0 +1,52 @@
+import { hasUpdates, identifyModelKey } from '~/core/model';
+
+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 isCollectionOutdated<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 hasUpdates(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/liveObject.ts

@@ -0,0 +1,83 @@
+import { getActiveClient } from '~/client/api';
+import {
+  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+import { hasUpdates } from '~/core/model';
+import { createQuery, runQuery } from '~/core/query';
+import { ASCApiError } from '~/core/errors';
+
+export const liveObject = <T extends Amity.Models[Amity.Domain], K extends keyof T>(
+  id: T[K],
+  callback: Amity.LiveObjectCallback<T>,
+  key: K,
+  fetcher: (id: T[K]) => Promise<Amity.Cached<T>>,
+  eventHandlers: Array<(callback: Amity.Listener<T>) => Amity.Unsubscriber>,
+): Amity.Unsubscriber => {
+  const { cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  }
+
+  let model: T;
+  let isUnsyncedModel = false; // for messages
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const dispatcher = (data: Amity.LiveObject<T>) => {
+    model = data.data;
+    callback(data);
+  };
+
+  const realtimeRouter = (eventModel: T) => {
+    if (id !== eventModel[key]) {
+      return;
+    }
+
+    if (model && !hasUpdates(model, eventModel)) {
+      return;
+    }
+
+    dispatcher({ loading: false, data: eventModel, origin: 'event' });
+  };
+
+  const onFetch = () => {
+    // @ts-ignore
+    const query = createQuery(fetcher, id, true);
+
+    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          // @ts-ignore
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedModel = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedModel) {
+        // @ts-ignore
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(...eventHandlers.map(fn => fn(realtimeRouter)));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/utils/tests/client.ts

@@ -0,0 +1,49 @@
+import {
+  createClient,
+  connectClient as sdkConnectClient,
+  disconnectClient as sdkDisconnectClient,
+} from '~/client/api';
+
+import { user11 } from './dummy';
+
+const sessionHandler: Amity.SessionHandler = {
+  sessionWillRenewAccessToken(_) {
+    // do nothing
+  },
+};
+
+export const client = createClient('key', 'sg');
+client.accessTokenExpiryWatcher = (_, __, ___) => () => {
+  //
+};
+
+export const connectClient = async () => {
+  const now = new Date();
+  const nextMonth = new Date();
+  nextMonth.setDate(now.getDate() + 30);
+
+  client.mqtt.connect = jest.fn();
+  client.mqtt.subscribe = jest.fn();
+  client.http.post = jest.fn().mockReturnValueOnce({
+    data: {
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+      users: [user11],
+      expiresAt: nextMonth.toISOString(),
+      issuedAt: now.toISOString(),
+    },
+  });
+
+  setTimeout(() => {
+    client.ws.emit('connect');
+    // fixes jest warning of open handles
+  }, 500).unref();
+
+  await sdkConnectClient({ userId: 'test' }, sessionHandler);
+};
+
+export const disconnectClient = async () => {
+  sdkDisconnectClient().then(() => client.ws.emit('disconnect'));
+};
+
+export default {};

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

@@ -0,0 +1,57 @@
+export const category11 = {
+  name: 'a-hello',
+  updatedAt: '2022-11-25T04:19:34.446Z',
+  createdAt: '2022-11-25T04:19:34.446Z',
+  isDeleted: false,
+  categoryId: '2ddea5ad242d0a2bd5dc5be8ae9fc8c2',
+};
+
+export const category12 = {
+  name: 'b-testing-category',
+  updatedAt: '2022-11-25T03:56:06.238Z',
+  createdAt: '2022-11-25T03:56:06.238Z',
+  isDeleted: false,
+  categoryId: '88d175da65cbfeb39b81e722b322430e',
+};
+
+export const category13 = {
+  name: 'c-deleted-category',
+  updatedAt: '2022-11-25T03:56:06.238Z',
+  createdAt: '2022-11-25T03:56:06.238Z',
+  isDeleted: true,
+  categoryId: '88d175da65cbfeb39b81e722b322430d',
+};
+
+export const category21 = {
+  name: 'a-0asd',
+  updatedAt: '2022-11-25T04:18:59.180Z',
+  createdAt: '2022-11-25T04:18:59.180Z',
+  isDeleted: false,
+  categoryId: '10051d82a1f371c6be3a8f4a4654b8a1',
+};
+
+export const category22 = {
+  name: 'b-A Category',
+  updatedAt: '2022-11-25T03:56:29.037Z',
+  createdAt: '2022-11-25T03:56:29.037Z',
+  isDeleted: false,
+  categoryId: '639942c6b2f121bed3901cf4a4c296e7',
+};
+
+export const categoryQueryResponse = {
+  data: {
+    categories: [category11, category12, category13],
+    paging: {
+      next: 'eyJza2lwIjoxMCwibGltaXQiOjEwfQ==',
+    },
+  },
+};
+
+export const categoryQueryResponsePage2 = {
+  data: {
+    categories: [category21, category22],
+    paging: {
+      next: 'eyJza2lwIjoxMCwibGltaXQiOjEwfQ==',
+    },
+  },
+};