@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

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/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/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==',
+    },
+  },
+};

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

@@ -0,0 +1,251 @@
+import { convertFromRaw } from '~/channel/utils';
+import { date, user11, user12, user13, user14, file11 } from '.';
+
+export function generateRawChannel(params?: Partial<Amity.RawChannel>): Amity.RawChannel {
+  const channelId = params?.channelId ?? 'channelId11';
+
+  return {
+    _id: `${channelId}-internalId`,
+    lastActivity: '',
+    channelId,
+    createdAt: date,
+    isDeleted: false,
+    messageCount: 0,
+    path: `${channelId}-path`,
+    tags: [],
+    type: 'community',
+    updatedAt: date,
+    ...params,
+  };
+}
+
+function generateRawChannelUser(
+  params?: Partial<Amity.RawMembership<'channel'>>,
+): Amity.RawMembership<'channel'> {
+  return {
+    channelId: 'channelId11',
+    createdAt: date,
+    isBanned: false,
+    isMuted: false,
+    lastActivity: date,
+    lastMentionedSegment: 0,
+    membership: 'member',
+    muteTimeout: '',
+    permissions: [],
+    readToSegment: 0,
+    roles: [],
+    userId: user11.userId,
+    ...params,
+  };
+}
+function convertChannelUserFromRaw(
+  member: Amity.RawMembership<'channel'>,
+  user: Amity.User,
+): Amity.Membership<'channel'> {
+  return {
+    ...member,
+    user,
+  };
+}
+
+export const mockPage = {
+  paging: {
+    previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  },
+};
+
+export const channelRaw1: Amity.RawChannel = generateRawChannel({ type: 'community' });
+
+export const channelRawLive1: Amity.RawChannel = generateRawChannel({ type: 'live' });
+
+export const channelRawConversation1: Amity.RawChannel = generateRawChannel({
+  type: 'conversation',
+});
+
+export const channelRaw2: Amity.RawChannel = generateRawChannel({
+  channelId: 'channelId12',
+  tags: ['tag1'],
+  type: 'conversation',
+});
+
+export const channelRaw3: Amity.RawChannel = generateRawChannel({
+  channelId: 'channelId21',
+});
+
+export const channel1: Amity.Channel = convertFromRaw(channelRaw1, {
+  defaultSubChannelHasUnreadMention: false,
+  defaultSubChannelUnreadCount: 0,
+  localLastMentionSegment: 0,
+  localReadToSegment: 0,
+});
+
+export const channel2: Amity.Channel = convertFromRaw(channelRaw2, {
+  defaultSubChannelHasUnreadMention: false,
+  defaultSubChannelUnreadCount: 0,
+  localLastMentionSegment: 0,
+  localReadToSegment: 0,
+});
+
+export const rawChannelUser = generateRawChannelUser();
+export const channelUser = convertChannelUserFromRaw(rawChannelUser, user11);
+
+export const rawChannelUser2 = generateRawChannelUser({
+  channelId: channel2.channelId,
+  lastMentionedSegment: 2,
+  readToSegment: 1,
+});
+export const channelUser2 = convertChannelUserFromRaw(rawChannelUser2, user11);
+
+export const rawChannelUser3 = generateRawChannelUser({
+  membership: 'none',
+  roles: ['test-role'],
+  userId: user12.userId,
+});
+export const channelUser3 = convertChannelUserFromRaw(rawChannelUser3, user12);
+
+export const channelUser4 = generateRawChannelUser({
+  membership: 'none',
+  roles: ['test-role'],
+  userId: user13.userId,
+});
+
+export const rawBannedChannelUser = generateRawChannelUser({
+  isBanned: true,
+  membership: 'banned',
+  userId: user13.userId,
+});
+export const bannedChannelUser = convertChannelUserFromRaw(rawBannedChannelUser, user13);
+
+export const rawMutedChannelUser = generateRawChannelUser({
+  isMuted: true,
+  userId: 'test',
+});
+export const mutedChannelUser = convertChannelUserFromRaw(rawMutedChannelUser, user11);
+
+export const rawChannelUserWithRole = generateRawChannelUser({
+  roles: ['test-role'],
+  userId: user14.userId,
+});
+export const channelUserWithRole = convertChannelUserFromRaw(rawChannelUserWithRole, user14);
+
+export const channelQueryResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw2],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const getChannelsResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw2, channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelQueryResponsePage2 = {
+  data: {
+    channels: [channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelTagQueryResponse = {
+  data: {
+    channels: [channelRaw2],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelExcludeTagQueryResponse = {
+  data: {
+    channels: [channelRaw1, channelRaw3],
+    channelUsers: [],
+    files: [],
+    users: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserQueryResponse = {
+  data: {
+    channels: [channelRaw1],
+    channelUsers: [rawChannelUser, rawChannelUser3],
+    users: [user11, user12],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const emptyChannelUserQueryResponse = {
+  data: {
+    channels: [channelRaw1],
+    channelUsers: [],
+    users: [],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserModel = [channelUser, { ...rawChannelUser3, user: user12 }];
+
+export const channelUserQueryResponsePage2 = {
+  data: {
+    channels: [channelRaw1],
+    channelUsers: [channelUser4],
+    users: [user13],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserQueryResponsePage3 = {
+  data: {
+    channels: [channelRaw1],
+    channelUsers: [rawChannelUserWithRole, rawMutedChannelUser, rawBannedChannelUser],
+    users: [user14, user11, user13],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const rawChannelPayload: Amity.ChannelPayload = {
+  channels: [channelRaw1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};
+
+// for testing ingest in cache
+export const channelPayload: Amity.ProcessedChannelPayload = {
+  channels: [channel1],
+  channelUsers: [channelUserWithRole, mutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};
+
+export const liveChannelPayload = {
+  channels: [channelRawLive1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};
+
+export const conversationChannelPayload = {
+  channels: [channelRawConversation1],
+  channelUsers: [rawChannelUserWithRole, rawMutedChannelUser],
+  users: [user14, user11],
+  files: [file11],
+};