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

package/src/community/events/utils.ts

@@ -0,0 +1,116 @@
+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>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommunityPayload) => {
+    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];
+  }
+
+  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

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

package/src/community/observers/observeCommunity.ts

@@ -0,0 +1,104 @@
+import { createQuery, runQuery } from '~/core/query/query';
+
+import { getActiveClient } from '~/client/api';
+
+import { getCommunity } from '../api';
+
+import {
+  onCommunityUpdated,
+  onCommunityDeleted,
+  onCommunityJoined,
+  onCommunityLeft,
+  onCommunityUserAdded,
+  onCommunityUserRemoved,
+  onCommunityUserBanned,
+  onCommunityUserUnbanned,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeCommunity } from '@amityco/ts-sdk'
+ *
+ * let community = {}
+ * const dispose = observeCommunity(communityId, updated => community = updated)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Community}
+ *
+ * @param communityId the ID of the community to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the community
+ *
+ * @category Community Observer
+ */
+export const observeCommunity = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onJoin',
+    'onLeft',
+    'onUserAdded',
+    'onUserRemoved',
+    'onUserBanned',
+    'onUserUnbanned',
+  ],
+>(
+  communityId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Community | undefined>, Events>,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeCommunity(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Community | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Community>, action: Events[number]) => {
+    if (result.data?.communityId !== communityId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    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 || result.error) && router(result, 'onFetch'),
+  );
+
+  return () => {
+    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

@@ -0,0 +1,26 @@
+import debug from 'debug';
+
+import { isProduction } from '~/utils/env';
+
+/**
+ * Creates a pre-configured logger instance
+ *
+ * @param session The name of the debug session
+ * @returns A pre-configured logger function
+ *
+ * @category Debug
+ * @hidden
+ */
+export const createLogger = (session?: string) => {
+  const active = `${session?.trim()}`.length > 0 && !isProduction;
+
+  const logger = debug(session!);
+
+  const print = (topic: string, ...args: any[]) => {
+    active && logger(topic, args);
+  };
+
+  // eslint-disable-next-line no-underscore-dangle
+  print.__instance__ = logger;
+  return print;
+};

package/src/core/device.ts

@@ -0,0 +1,38 @@
+// TODO: find a way to uniquely identify the device
+// import { getStorage } from './storage'
+import { safeProcess } from '~/utils/env';
+
+/** @hidden */
+const VERSION = '11.0.0';
+
+/** @hidden */
+export const getDeviceId = () => {
+  // here maybe put some auto detection of the device id based on if it's react or not?
+  // anyhow we let consumer branch out if they want, but it doesn't mean we shouldn't try to be nice
+  // 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)}`;
+};
+
+/** @hidden */
+export const getDeviceModel = () => {
+  if (safeProcess.versions?.node) return safeProcess.versions.node;
+
+  if (navigator)
+    return `${navigator.product.toLowerCase()}#${navigator.userAgent ?? 'unknown_agent'}`;
+
+  return 'unknown_model';
+};
+
+/** @hidden */
+export const getDeviceInfo = (): Amity.Device['deviceInfo'] => {
+  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

@@ -0,0 +1,89 @@
+/* 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();
+
+  /**
+   * @param message A custom error message
+   * @param code A normalized error code
+   * @param level A normalized failure level descriptor
+   */
+  constructor(
+    message: string,
+    public readonly code: Amity.ErrorCode,
+    public readonly level: Amity.ErrorLevel,
+  ) {
+    super(`Amity SDK (${code}): ${message}`);
+
+    if (Error.captureStackTrace) Error.captureStackTrace(this, ASCError);
+  }
+}
+
+/**
+ * API level error
+ * @category Errors
+ */
+export class ASCApiError extends ASCError {
+  /**
+   * @param code A normalized error code
+   * @param level A normalized failure level descriptor
+   */
+  // eslint-disable-next-line no-useless-constructor
+  constructor(message: string, code: Amity.ErrorCode, level: Amity.ErrorLevel) {
+    super(message, code, level);
+  }
+}
+
+/**
+ * Unexpected error
+ * @category Errors
+ */
+export class ASCUnknownError extends ASCError {
+  /**
+   * @param code A normalized error code
+   * @param level A normalized failure level descriptor
+   */
+  constructor(
+    code: Amity.ErrorCode = Amity.ClientError.UNKNOWN_ERROR,
+    level: Amity.ErrorLevel = Amity.ErrorLevel.FATAL,
+  ) {
+    super('Unexpected error', code, level);
+  }
+}
+
+/**
+ * Network related error
+ * @category Errors
+ */
+export class ASCConnectionError extends ASCError {
+  /**
+   * @param message A custom error message
+   */
+  constructor(public readonly event: string, message = 'SDK client is having connection issues') {
+    super(
+      `${message} (${event})`,
+      event === 'disconnected'
+        ? Amity.ClientError.DISCONNECTED
+        : Amity.ClientError.CONNECTION_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+  }
+}
+
+/**
+ * Input sanitization related error
+ * @category Errors
+ */
+export class ASCInvalidParameterError extends ASCError {
+  /**
+   * @param message A custom error message
+   */
+  constructor(message: string) {
+    super(message, Amity.ClientError.INVALID_PARAMETERS, Amity.ErrorLevel.ERROR);
+  }
+}

package/src/core/events.ts

@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import mitt from 'mitt';
+
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { scheduleTask } from './microtasks';
+
+// need to sync up the list
+const WS_EVENTS = [
+  'disconnected',
+  'error',
+  'connect_error',
+  'reconnect_error',
+  'reconnect_failed',
+
+  'v3.channel.didCreate',
+  'v3.channel.didUpdate',
+  'v3.channel.didDelete',
+  'v3.channel.didMarkSeen',
+  'v3.channel.didJoin',
+  'v3.channel.didLeave',
+  'v3.channel.didAddUsers',
+  'v3.channel.didRemoveUsers',
+  'v3.channel.didBan',
+  'v3.channel.didUnban',
+
+  'v3.message.didFetch',
+  'v3.message.didCreate',
+  'v3.message.didUpdate',
+  'v3.message.didDelete',
+] as const;
+
+const MQTT_EVENTS = [
+  'connect',
+  'message',
+  'disconnect',
+  'error',
+  'close',
+  'end',
+  'reconnect',
+] as const;
+
+/** @hidden */
+export const createEventEmitter = () => {
+  return mitt<Amity.Events>();
+};
+
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+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));
+  });
+};
+
+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
+ *
+ * @param client The current client for which to subscribe the event to
+ * @param namespace A unique name for the logger
+ * @param event The websocket event name
+ * @param fn A wrapper for the callback.
+ * @returns A dispose function to unsubscribe to the event
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createEventSubscriber = <T extends keyof Amity.Events>(
+  client: Amity.Client,
+  namespace: string,
+  event: T,
+  fn: Amity.Listener<Amity.Events[T]>,
+): Amity.Unsubscriber => {
+  const { log, emitter } = client;
+
+  const timestamp = Date.now();
+  log(`${namespace}(tmpid: ${timestamp}) > listen`);
+
+  const handler = (...payload: Parameters<typeof fn>) => {
+    log(`${namespace}(tmpid: ${timestamp}) > trigger`, payload);
+    fn(...payload);
+  };
+
+  emitter.on(event, handler);
+
+  return () => {
+    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();
+  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

@@ -0,0 +1,41 @@
+/**
+ * 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 Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
+  [K in T[number]]: (model: Amity.Minimal[K]) => string;
+};
+
+/** @hidden */
+const idResolvers: Resolvers = {
+  user: ({ userId }) => userId,
+  file: ({ fileId }) => fileId,
+  role: ({ roleId }) => roleId,
+
+  channel: ({ channelId }) => channelId,
+  channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
+  message: ({ messageId }) => messageId,
+
+  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}`,
+  followCount: ({ userId }) => userId,
+};
+
+/**
+ * Retrieve the id resolver matching a domain name
+ *
+ * @param name the domain name for the resolve
+ * @returns an idResolver function for the given domain name
+ */
+export const getResolver = <T extends Amity.Domain>(name: T): Resolvers[T] => idResolvers[name];