@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-bef76fa.0

package/src/community/events/onCommunityUserUnbanned.ts

@@ -1,19 +1,20 @@
-import { createCommunityEventSubscriber } from './utils'
+import { createCommunityMemberEventSubscriber } from './utils';
 
 /**
  * ```js
  * import { onCommunityUserUnbanned } from '@amityco/ts-sdk'
- * const dispose = onCommunityUserUnbanned(community => {
+ * const dispose = onCommunityUserUnbanned((community, member) => {
  *   // ...
  * })
  * ```
  *
- * Fired when any {@link Amity.Community} have been updated
+ * Fired when a user has been unbanned from a {@link Amity.Community}
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Community Events
  */
-export const onCommunityUserUnbanned = (callback: Amity.Listener<Amity.Community>) =>
-  createCommunityEventSubscriber('community.userUnbanned', callback)
+export const onCommunityUserUnbanned = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => createCommunityMemberEventSubscriber('community.userUnbanned', callback);

package/src/community/events/utils.ts

@@ -1,24 +1,116 @@
-import { getActiveClient } from '~/client/api'
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { createEventSubscriber } from '~/core/events';
+import { pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { unpackCommunityPayload } from '../utils';
 
 export const createCommunityEventSubscriber = (
   event: keyof Amity.MqttCommunityMessageEvents,
-  callback: Amity.Listener<Amity.Community>
+  callback: Amity.Listener<Amity.Community>,
 ) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityPayload) => {
-    decoratePayload(payload)
-    ingestInCache(payload)
-    callback(payload.communities[0])
+    const unpackedPayload = unpackCommunityPayload(payload);
+
+    if (!client.cache) {
+      // TODO: here we are missing specific properties here!
+      callback(unpackedPayload.communities[0]);
+    } else {
+      ingestInCache(unpackedPayload);
+
+      const community = pullFromCache<Amity.Community>([
+        'community',
+        'get',
+        unpackedPayload.communities[0].communityId,
+      ])!;
+
+      callback(community.data);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};
+
+function hasPermission(
+  member: Amity.Membership<'community'>,
+  payload: {
+    users: Amity.User[];
+  },
+  permission: string,
+) {
+  if (member.permissions.some(x => x === permission)) {
+    return true;
+  }
+
+  return payload
+    .users!.find(user => user.userId === member.userId)!
+    .permissions.some(x => x === permission);
+}
+
+function getEventRelatedMember(
+  event: keyof Amity.MqttCommunityUserMessageEvents,
+  payload: {
+    communityUsers: Amity.Membership<'community'>[];
+    users: Amity.User[];
+  },
+) {
+  if (event === 'community.joined' || event === 'community.left') {
+    return payload.communityUsers![0];
+  }
+
+  // NOTE: backend returns the one who took the action and the one on whom
+  // the action was taken. We need the 2nd one
+  if (event === 'community.userRemoved') {
+    return payload.communityUsers!.filter(x => x.communityMembership === 'none')[0];
   }
 
-  return createEventSubscriber(
-    client,
-    event,
-    event,
-    filter
-  )
+  if (event === 'community.userBanned') {
+    return payload.communityUsers!.filter(x => x.communityMembership === 'banned')[0];
+  }
+
+  // NOTE: it might be that in certain edge cases permission check won't be enough
+  if (event === 'community.userUnbanned') {
+    return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'BAN_COMMUNITY_USER'))[0];
+  }
+
+  return payload.communityUsers!.filter(x => !hasPermission(x, payload, 'ADD_COMMUNITY_USER'))[0];
 }
+
+export const createCommunityMemberEventSubscriber = (
+  event: keyof Amity.MqttCommunityUserMessageEvents,
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommunityMembershipPayload) => {
+    const communityPayload = unpackCommunityPayload(payload);
+    const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
+
+    if (!client.cache) {
+      // TODO: here we are missing specific properties here!
+      callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
+    } else {
+      ingestInCache(preparedPayload);
+
+      const community = pullFromCache<Amity.Community>([
+        'community',
+        'get',
+        preparedPayload.communities[0].communityId,
+      ])!;
+
+      const member = pullFromCache<Amity.Membership<'community'>>([
+        'communityUsers',
+        'get',
+        getResolver('communityUsers')(getEventRelatedMember(event, preparedPayload)),
+      ])!;
+
+      callback(community.data, member.data);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/community/observers/index.ts

@@ -1 +1 @@
-export * from './observeCommunity'
+export * from './observeCommunity';

package/src/community/observers/observeCommunity.ts

@@ -1,9 +1,8 @@
-import { createQuery, runQuery } from '~/core/query/query'
-import { getTopic, subscribe } from '~/core/subscription'
+import { createQuery, runQuery } from '~/core/query/query';
 
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { getCommunity } from '../api'
+import { getCommunity } from '../api';
 
 import {
   onCommunityUpdated,
@@ -13,8 +12,8 @@ import {
   onCommunityUserAdded,
   onCommunityUserRemoved,
   onCommunityUserBanned,
-  onCommunityUserUnbanned
-} from '../events'
+  onCommunityUserUnbanned,
+} from '../events';
 
 /**
  * ```js
@@ -32,56 +31,74 @@ import {
  *
  * @category Community Observer
  */
-export const observeCommunity = <Events extends ['onFetch', 'onUpdate', 'onDelete', 'onJoin', 'onLeft', 'onUserAdded', 'onUserRemoved', 'onUserBanned', 'onUserUnbanned']>(
+export const observeCommunity = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onJoin',
+    'onLeft',
+    'onUserAdded',
+    'onUserRemoved',
+    'onUserBanned',
+    'onUserUnbanned',
+  ],
+>(
   communityId: string,
-  callback: Amity.ObjectListener<Amity.QueryResult<Amity.Community>, Events>
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Community | undefined>, Events>,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeCommunity(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeCommunity(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (
-    result: Amity.QueryResult<Amity.Community>,
-    action: Events[number]
-  ) => {
-    // filter function
-    if (result.data?.communityId !== communityId) return
+  const router = (result: Amity.Snapshot<Amity.Community | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
 
-    if (action === 'onFetch') {
-      disposers.push(subscribe(getTopic(result.data)))
-    }
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    if (callback instanceof Function)
-      return callback(result)
+    callback[action]?.(result);
+  };
 
-    if (action !== 'onFetch')
-      callback.onEvent?.(action, result)
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Community>, action: Events[number]) => {
+    if (result.data?.communityId !== communityId) return;
 
-    callback[action]?.(result)
-  }
+    router(result, action);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onCommunityUpdated(data => router({ data }, 'onUpdate')),
-    onCommunityDeleted(data => router({ data }, 'onDelete')),
-    onCommunityJoined(data => router({ data }, 'onJoin')),
-    onCommunityLeft(data => router({ data }, 'onLeft')),
-    onCommunityUserAdded(data => router({ data }, 'onUserAdded')),
-    onCommunityUserRemoved(data => router({ data }, 'onUserRemoved')),
-    onCommunityUserBanned(data => router({ data }, 'onUserBanned')),
-    onCommunityUserUnbanned(data => router({ data }, 'onUserUnbanned')),
-  )
+    onCommunityUpdated(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate'),
+    ),
+    onCommunityDeleted(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete'),
+    ),
+    onCommunityJoined(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onJoin')),
+    onCommunityLeft(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onLeft')),
+    onCommunityUserAdded(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserAdded'),
+    ),
+    onCommunityUserRemoved(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserRemoved'),
+    ),
+    onCommunityUserBanned(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserBanned'),
+    ),
+    onCommunityUserUnbanned(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUserUnbanned'),
+    ),
+  );
 
   runQuery(
     createQuery(getCommunity, communityId),
-    result => result.data && router(result, 'onFetch')
-  )
+    result => (result.data || result.error) && router(result, 'onFetch'),
+  );
 
   return () => {
-    log(`observeCommunity(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeCommunity(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/community/utils/index.ts

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

package/src/community/utils/payload.ts

@@ -0,0 +1,44 @@
+import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+
+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;
+
+/*
+ * Unpack community payload by mapping payload field to postSetting value.
+ */
+export const unpackCommunityPayload = <T extends Amity.CommunityPayload>({
+  communities,
+  ...restPayload
+}: T) => ({
+  communities: communities.map<Amity.Community>(
+    ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
+      postSetting: getMatchPostSetting({
+        needApprovalOnPostCreation,
+        onlyAdminCanPost,
+      }),
+      ...restCommunityPayload,
+    }),
+  ),
+  ...restPayload,
+});
+
+/*
+ * Repack community payload by mapping postSetting to the actual value.
+ */
+export const packCommunityPayload = <
+  T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
+>({
+  postSetting = undefined,
+  ...restParam
+}: T) => ({
+  ...restParam,
+  ...(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,9 @@
 // TODO: find a way to uniquely identify the device
 // import { getStorage } from './storage'
+import { safeProcess } from '~/utils/env';
 
 /** @hidden */
-const VERSION = '11.0.0'
+const VERSION = '11.0.0';
 
 /** @hidden */
 export const getDeviceId = () => {
@@ -11,28 +12,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,
-  }
-}
+  };
+};

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,6 +1,9 @@
-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 WS_EVENTS = [
@@ -10,8 +13,10 @@ const WS_EVENTS = [
   'reconnect_error',
   'reconnect_failed',
 
+  'v3.channel.didCreate',
   'v3.channel.didUpdate',
-  'v3.channel.didUpdate',
+  'v3.channel.didDelete',
+  'v3.channel.didMarkSeen',
   'v3.channel.didJoin',
   'v3.channel.didLeave',
   'v3.channel.didAddUsers',
@@ -19,10 +24,11 @@ const WS_EVENTS = [
   'v3.channel.didBan',
   'v3.channel.didUnban',
 
+  'v3.message.didFetch',
   'v3.message.didCreate',
   'v3.message.didUpdate',
   'v3.message.didDelete',
-] as const
+] as const;
 
 const MQTT_EVENTS = [
   'connect',
@@ -31,13 +37,13 @@ const MQTT_EVENTS = [
   'error',
   'close',
   'end',
-  'reconnect'
+  'reconnect',
 ] 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
@@ -51,22 +57,27 @@ export const createEventEmitter = () => {
  */
 export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
   WS_EVENTS.forEach(event => {
-    ws.on(event, (param: Amity.Events[typeof event]) => emitter.emit(event, param))
-  })
-}
+    ws.on(event, (param: Amity.Events[typeof event]) => emitter.emit(event, param));
+  });
+};
 
-export const proxyMqttEvents = (mqttClient: Amity.Client['mqtt'], emitter: Amity.Client['emitter']) => {
+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))
-  })
+    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)
-  })
-}
+    emitter.emit(message.eventType, message.data);
+  });
+};
 
 /**
  * Standardize the subscription of SSE through web sockets
@@ -86,53 +97,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: string,
-  fn: (params: Object) => void,
+  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);
-      }
+  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);
+  });
+};