@amityco/ts-sdk 1.0.0-8aae813.0 → 6.0.0-beta01

package/src/communityRepository/observers/tests/getCommunity.test.ts

@@ -0,0 +1,147 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  user11,
+  communityUser11,
+  communityUser12,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+
+import { getCommunity } from '../getCommunity';
+
+const { communityId } = community11;
+const response = {
+  data: {
+    communities: [community11],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('getCommunity events', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.MqttCommunityEvents][] = [
+    ['it should get update on community.updated event', 'community.updated'],
+    ['it should get update on community.deleted event', 'community.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update =
+      event === 'community.updated'
+        ? {
+            ...community11,
+            displayName: 'updated-name',
+            updatedAt: getFutureDate(community11.updatedAt),
+          }
+        : {
+            ...community11,
+            isDeleted: true,
+            updatedAt: getFutureDate(community11.updatedAt),
+          };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const unsub = getCommunity(communityId, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities: [update],
+      communityUsers: [],
+      categories: [],
+      feeds: [],
+      users: [user11],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+
+    unsub();
+  });
+
+  const communityUserEvents: [string, keyof Amity.MqttCommunityUserEvents][] = [
+    ['it should add user on community.joined event', 'community.joined'],
+    ['it should get update on community.left event', 'community.left'],
+    ['it should get update on community.userChanged event', 'community.userChanged'],
+    ['it should get update on community.userBanned event', 'community.userBanned'],
+    ['it should get update on community.userUnbanned event', 'community.userUnbanned'],
+  ];
+
+  test.each(communityUserEvents)('%s', async (test, event) => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    const community = {
+      ...community11,
+      updatedAt: getFutureDate(community11.updatedAt),
+    };
+    let communityUsers: Amity.RawMembership<'community'>[];
+    let communities: Amity.RawCommunity[];
+
+    switch (event) {
+      case 'community.userChanged':
+      case 'community.left':
+        communityUsers = [communityUser11];
+        communities = [{ ...community, isJoined: true }];
+        break;
+
+      case 'community.userBanned':
+        communities = [{ ...community, isJoined: true }];
+        communityUsers = [{ ...communityUser11, communityMembership: 'banned' }];
+        break;
+
+      case 'community.userUnbanned':
+        communityUsers = [communityUser11];
+        communities = [{ ...community, isJoined: true }];
+        break;
+
+      // community.joined
+      default:
+        communities = [community];
+        communityUsers = [communityUser12];
+    }
+
+    const unsub = getCommunity(communityId, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      communities,
+      communityUsers,
+      categories: [],
+      feeds: [],
+      users: [user11],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: communities[0],
+      }),
+    );
+
+    unsub();
+  });
+});

package/src/communityRepository/utils/index.ts

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

package/src/communityRepository/utils/payload.ts

@@ -0,0 +1,50 @@
+import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+import { withUsers } from '~/group/utils';
+
+const getMatchPostSetting = (value: {
+  needApprovalOnPostCreation: Amity.RawCommunity['needApprovalOnPostCreation'];
+  onlyAdminCanPost: Amity.RawCommunity['onlyAdminCanPost'];
+}): Amity.Community['postSetting'] =>
+  Object.keys(CommunityPostSettingMaps).find(
+    key =>
+      value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+      value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
+  ) ?? DefaultCommunityPostSetting;
+
+export const prepareCommunityPayload = (
+  rawPayload: Amity.CommunityPayload,
+): Amity.ProcessedCommunityPayload => {
+  // Unpack community payload by mapping payload field to postSetting value.
+  const communities = rawPayload.communities.map<Amity.Community>(
+    ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
+      postSetting: getMatchPostSetting({
+        needApprovalOnPostCreation,
+        onlyAdminCanPost,
+      }),
+      ...restCommunityPayload,
+    }),
+  );
+
+  const communityUsers = withUsers(rawPayload.communityUsers);
+
+  return {
+    ...rawPayload,
+    communities,
+    communityUsers,
+  };
+};
+
+export const prepareCommunityRequest = <
+  T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
+>(
+  params: T,
+) => {
+  const { postSetting = undefined, ...restParam } = params;
+
+  return {
+    ...restParam,
+    // Repack community payload by mapping postSetting to the actual value.
+    ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+  };
+};

package/src/core/debug.ts

@@ -1,4 +1,6 @@
-import debug from 'debug'
+import debug from 'debug';
+
+import { isProduction } from '~/utils/env';
 
 /**
  * Creates a pre-configured logger instance
@@ -10,17 +12,15 @@ import debug from 'debug'
  * @hidden
  */
 export const createLogger = (session?: string) => {
-  const active = (
-      `${session?.trim()}`.length > 0
-    && process.env.NODE_ENV !== 'production'
-  )
+  const active = `${session?.trim()}`.length > 0 && !isProduction;
 
-  const logger = debug(session!)
+  const logger = debug(session!);
 
   const print = (topic: string, ...args: any[]) => {
-    active && logger(topic, args)
-  }
+    active && logger(topic, args);
+  };
 
-  print.__instance__ = logger
-  return print
-}
+  // eslint-disable-next-line no-underscore-dangle
+  print.__instance__ = logger;
+  return print;
+};

package/src/core/device.ts

@@ -1,8 +1,7 @@
 // TODO: find a way to uniquely identify the device
 // import { getStorage } from './storage'
-
-/** @hidden */
-const VERSION = '11.0.0'
+import { safeProcess } from '~/utils/env';
+import { VERSION } from '~/version';
 
 /** @hidden */
 export const getDeviceId = () => {
@@ -11,28 +10,27 @@ export const getDeviceId = () => {
   // and do things automatically
   // https://www.npmjs.com/package/react-native-device-info#getuniqueid
   // how to make sure that the react native package will not be included when build is for web
-  return `ascWebSdk#${Math.random().toString(16)}`
-}
+  return `ascWebSdk#${Math.random().toString(16)}`;
+};
 
 /** @hidden */
 export const getDeviceModel = () => {
-  if (process?.versions?.node)
-    return process.versions.node
+  if (safeProcess.versions?.node) return safeProcess.versions.node;
 
   if (navigator)
-    return `${navigator.product.toLowerCase()}#${navigator.userAgent ?? 'unknown_agent'}`
+    return `${navigator.product.toLowerCase()}#${navigator.userAgent ?? 'unknown_agent'}`;
 
-  return 'unknown_model'
-}
+  return 'unknown_model';
+};
 
 /** @hidden */
 export const getDeviceInfo = (): Amity.Device['deviceInfo'] => {
-  const model = getDeviceModel()
+  const model = getDeviceModel();
 
   return {
-    version: VERSION,
     // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
     kind: 'web',
     model,
-  }
-}
+    sdkVersion: VERSION,
+  };
+};

package/src/core/errors.ts

@@ -1,10 +1,12 @@
+/* eslint-disable max-classes-per-file */
 /**
  * Generic ASC error
  * @category Errors
  */
 export class ASCError extends Error {
-  readonly type: string = 'ASC'
-  readonly timestamp: number = Date.now()
+  readonly type: string = 'ASC';
+
+  readonly timestamp: number = Date.now();
 
   /**
    * @param message A custom error message
@@ -16,10 +18,9 @@ export class ASCError extends Error {
     public readonly code: Amity.ErrorCode,
     public readonly level: Amity.ErrorLevel,
   ) {
-    super(`Amity SDK (${code}): ${message}`)
+    super(`Amity SDK (${code}): ${message}`);
 
-    if (Error.captureStackTrace)
-      Error.captureStackTrace(this, ASCError)
+    if (Error.captureStackTrace) Error.captureStackTrace(this, ASCError);
   }
 }
 
@@ -32,12 +33,9 @@ export class ASCApiError extends ASCError {
    * @param code A normalized error code
    * @param level A normalized failure level descriptor
    */
-  constructor(
-    message: string,
-    code: Amity.ErrorCode,
-    level: Amity.ErrorLevel,
-  ) {
-    super(message, code, level)
+  // eslint-disable-next-line no-useless-constructor
+  constructor(message: string, code: Amity.ErrorCode, level: Amity.ErrorLevel) {
+    super(message, code, level);
   }
 }
 
@@ -54,7 +52,7 @@ export class ASCUnknownError extends ASCError {
     code: Amity.ErrorCode = Amity.ClientError.UNKNOWN_ERROR,
     level: Amity.ErrorLevel = Amity.ErrorLevel.FATAL,
   ) {
-    super('Unexpected error', code, level)
+    super('Unexpected error', code, level);
   }
 }
 
@@ -66,15 +64,14 @@ export class ASCConnectionError extends ASCError {
   /**
    * @param message A custom error message
    */
-  constructor(
-    public readonly event: string,
-    message: string = 'SDK client is having connection issues',
-  ) {
+  constructor(public readonly event: string, message = 'SDK client is having connection issues') {
     super(
       `${message} (${event})`,
-      event === 'disconnected' ? Amity.ClientError.DISCONNECTED : Amity.ClientError.CONNECTION_ERROR,
+      event === 'disconnected'
+        ? Amity.ClientError.DISCONNECTED
+        : Amity.ClientError.CONNECTION_ERROR,
       Amity.ErrorLevel.ERROR,
-    )
+    );
   }
 }
 
@@ -87,6 +84,6 @@ export class ASCInvalidParameterError extends ASCError {
    * @param message A custom error message
    */
   constructor(message: string) {
-    super(message, Amity.ClientError.INVALID_PARAMETERS, Amity.ErrorLevel.ERROR)
+    super(message, Amity.ClientError.INVALID_PARAMETERS, Amity.ErrorLevel.ERROR);
   }
 }

package/src/core/events.ts

@@ -1,35 +1,38 @@
-import mitt from 'mitt'
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import mitt from 'mitt';
 
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { scheduleTask } from './microtasks';
 
 // need to sync up the list
-const EVENTS = [
+const WS_EVENTS = [
   'disconnected',
   'error',
   'connect_error',
   'reconnect_error',
   'reconnect_failed',
+  'sessionStateChange',
+  // for internal use by accessTokenExpiryWatcher
+  'tokenExpired',
+] as const;
 
-  'v3.user.didUpdate',
-
-  'v3.channel.didUpdate',
-  'v3.channel.didUpdate',
-  'v3.channel.didJoin',
-  'v3.channel.didLeave',
-  'v3.channel.didAddUsers',
-  'v3.channel.didRemoveUsers',
-  'v3.channel.didBan',
-  'v3.channel.didUnban',
+const MQTT_EVENTS = [
+  'connect',
+  'message',
+  'disconnect',
+  'error',
+  'close',
+  'end',
+  'reconnect',
 
-  'v3.message.didCreate',
-  'v3.message.didUpdate',
-  'v3.message.didDelete',
-] as const
+  'user.didGlobalBan',
+] as const;
 
 /** @hidden */
 export const createEventEmitter = () => {
-  return mitt<Amity.Events>()
-}
+  return mitt<Amity.Events>();
+};
 
 /**
  * Wraps the websocket events into the client's event emitter for
@@ -42,10 +45,29 @@ export const createEventEmitter = () => {
  * @hidden
  */
 export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
-  EVENTS.forEach(event => {
-    ws.on(event, (param: Amity.Events[typeof event]) => emitter.emit(event, param))
-  })
-}
+  WS_EVENTS.forEach(event => {
+    ws.on(event, (param: Amity.Events[typeof event]) => {
+      emitter.emit(event, param);
+    });
+  });
+};
+
+export const proxyMqttEvents = (
+  mqttClient: Amity.Client['mqtt'],
+  emitter: Amity.Client['emitter'],
+) => {
+  MQTT_EVENTS.forEach(event => {
+    mqttClient.on(event, (...params: any[]) => {
+      emitter.emit(event, params.length === 1 ? params[0] : params);
+    });
+  });
+
+  // @ts-ignore
+  mqttClient.on('message', (topic: string, payload: Buffer) => {
+    const message = JSON.parse(payload.toString());
+    emitter.emit(message.eventType, message.data);
+  });
+};
 
 /**
  * Standardize the subscription of SSE through web sockets
@@ -65,33 +87,47 @@ export const createEventSubscriber = <T extends keyof Amity.Events>(
   event: T,
   fn: Amity.Listener<Amity.Events[T]>,
 ): Amity.Unsubscriber => {
-  const { log, emitter } = client
+  const { log, emitter } = client;
 
-  const timestamp = Date.now()
-  log(`${namespace}(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`${namespace}(tmpid: ${timestamp}) > listen`);
 
   const handler = (...payload: Parameters<typeof fn>) => {
-    log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload)
-    fn(...payload)
-  }
+    log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
+    fn(...payload);
+  };
 
-  emitter.on(event, handler)
+  emitter.on(event, handler);
 
   return () => {
-    log(`${namespace}(tmpid: ${timestamp}) > dispose`)
-    emitter.off(event, handler)
-  }
-}
+    log(`${namespace}(tmpid: ${timestamp}) > dispose`);
+    emitter.off(event, handler);
+  };
+};
+
+export const createMqttMessageSubscriber = <T extends keyof Amity.Events>(
+  client: Amity.Client,
+  namespace: string,
+  event: T,
+  fn: (params: Record<string, unknown>) => void,
+): Amity.Unsubscriber => {
+  return createEventSubscriber(client, namespace, 'message', ([topic, message]) => {
+    const payload = JSON.parse(message.toString());
+
+    if (payload.eventType === event) {
+      fn(payload.data);
+    }
+  });
+};
 
 /**
  * Wrapper around dispatch event
  *
  * @hidden
  */
-export const fireEvent = <T extends keyof Amity.Events>(
-  event: T,
-  payload: Amity.Events[T],
-) => {
-  const { emitter } = getActiveClient()
-  setTimeout(() => { emitter.emit(event, payload) }, 0)
-}
+export const fireEvent = <T extends keyof Amity.Events>(event: T, payload: Amity.Events[T]) => {
+  const { emitter } = getActiveClient();
+  scheduleTask(() => {
+    emitter.emit(event, payload);
+  });
+};

package/src/core/microtasks.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/ban-types */
+let tasks: Function[] = [];
+let timer: NodeJS.Timeout;
+
+/**
+ * Add a function to run just before the next tick
+ *
+ * @param task function to schedule for later execution
+ */
+export const scheduleTask = (task: Function) => {
+  clearTimeout(timer);
+  tasks.push(task);
+
+  timer = setTimeout(() => {
+    tasks.forEach(fn => fn());
+    tasks = [];
+  }, 0);
+};
+
+/**
+ * Cancel the scheduling operation
+ *
+ * @param task function to be removed from later execution
+ */
+export const cancelTask = (task: Function) => {
+  tasks = tasks.filter(fn => fn !== task);
+  if (!tasks.length) clearTimeout(timer);
+};

package/src/core/model/idResolvers.ts

@@ -1,67 +1,53 @@
 /**
- * A resolver function is a function which, given a minimal version of a model T
- * can compute a string which is capable of identifying the given model uniquely
- * @hidden
+ * Manually computed type which links each key with a function
+ * used to return the object's unique id. The type is computed
+ * to avoid using any and give some typing security at the
+ * resolver's level.
  */
-type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string
+type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string;
+type Resolvers<T extends Amity.Domain = Amity.Domain> = {
+  [K in T]: Resolver<K>;
+};
 
-/**
- * Manually computed type to output a dictionary of { Domain: Amity.Resolver<Model> }
- * with proper typing based on T
- * @hidden
- */
-type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: Resolver<K>
-}
-
-/**
- * Dictionary of resolver functions for each model
- * @hidden
- */
+/** @hidden */
 const idResolvers: Resolvers = {
   user: ({ userId }) => userId,
   file: ({ fileId }) => fileId,
   role: ({ roleId }) => roleId,
 
   channel: ({ channelId }) => channelId,
+  subChannel: ({ subChannelId }) => subChannelId,
   channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
   message: ({ messageId }) => messageId,
 
+  channelMarker: ({ entityId, userId }) => `${entityId}#${userId}`,
+  subChannelMarker: ({ entityId, feedId, userId }) => `${entityId}#${feedId}#${userId}`,
+  messageMarker: ({ feedId, contentId, creatorId }) => `${feedId}#${contentId}#${creatorId}`,
+  feedMarker: ({ feedId, entityId }) => `${feedId}#${entityId}`,
+
+  userMarker: ({ userId }) => userId,
+
   community: ({ communityId }) => communityId,
+  category: ({ categoryId }) => categoryId,
   communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,
   post: ({ postId }) => postId,
   comment: ({ commentId }) => commentId,
+  poll: ({ pollId }) => pollId,
+  reaction: ({ reactionId }) => reactionId,
 
   stream: ({ streamId }) => streamId,
-}
+
+  follow: ({ from, to }) => `${from}#${to}`,
+  followInfo: ({ userId }) => userId,
+  followCount: ({ userId }) => userId,
+
+  feed: ({ targetId, feedId }) => `${targetId}#${feedId}`,
+};
 
 /**
  * Retrieve the id resolver matching a domain name
  *
  * @param name the domain name for the resolve
- * @returns an idResolver for the given domain name
+ * @returns an idResolver function for the given domain name
  */
-export const getResolver = <T extends Amity.Domain>(name: T) => (
-  idResolvers[name] as Resolver<T>
-)
-
-/**
- * A map of v3 response keys to a store name.
- * @hidden
- */
-export const storeInterests: Record<string, Amity.Domain> = {
-  users: 'user',
-  files: 'file',
-  roles: 'role',
-
-  channels: 'channel',
-  channelUsers: 'channelUsers',
-  messages: 'message',
-
-  communities: 'community',
-  communityUsers: 'communityUsers',
-  posts: 'post',
-  postChildren: 'post',
-  comments: 'comment',
-  videoStreamings: 'stream',
-}
+export const getResolver = <T extends Amity.Domain>(name: T): Resolver<T> => idResolvers[name];