@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/communityRepository/utils/payload.ts

@@ -0,0 +1,140 @@
+import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+import { updateMembershipStatus } from './communityWithMembership';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+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 function addPostSetting({ communities }: { communities: Amity.RawCommunity[] }) {
+  return communities.map<Amity.InternalCommunity>(
+    ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
+      postSetting: getMatchPostSetting({
+        needApprovalOnPostCreation,
+        onlyAdminCanPost,
+      }),
+      ...restCommunityPayload,
+    }),
+  );
+}
+
+export const prepareCommunityPayload = (
+  rawPayload: Amity.CommunityPayload,
+): Amity.ProcessedCommunityPayload => {
+  const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+
+  // Convert users to internal format
+  const internalUsers = rawPayload.users.map(convertRawUserToInternalUser);
+
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = rawPayload.communityUsers.map(
+    communityUser => {
+      const user = internalUsers.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
+
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
+
+  return {
+    ...rawPayload,
+    users: rawPayload.users.map(convertRawUserToInternalUser),
+    communities: communityWithMembershipStatus,
+    communityUsers: mappedCommunityUsers,
+  };
+};
+
+export const prepareCommunityJoinRequestPayload = (
+  rawPayload: Amity.CommunityJoinRequestPayload,
+): Amity.ProcessedJoinRequestPayload => {
+  const mappedJoinRequests: Array<Amity.InternalJoinRequest> = rawPayload.joinRequests.map(
+    joinRequest => {
+      return {
+        ...joinRequest,
+        joinRequestId: joinRequest._id,
+      };
+    },
+  );
+
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
+
+  return {
+    ...rawPayload,
+    joinRequests: mappedJoinRequests,
+    users,
+  };
+};
+
+export const prepareCommunityMembershipPayload = (
+  rawPayload: Amity.CommunityMembershipPayload,
+): Amity.ProcessedCommunityMembershipPayload => {
+  const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = rawPayload.communityUsers.map(
+    communityUser => {
+      const user = rawPayload.users.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
+
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
+
+  return {
+    ...rawPayload,
+    communities: communityWithMembershipStatus,
+    communityUsers: mappedCommunityUsers,
+  };
+};
+
+export const prepareCommunityRequest = <
+  T extends {
+    postSetting?: Amity.Community['postSetting'];
+    [k: string]: any;
+  },
+>(
+  params: T,
+) => {
+  const { postSetting = undefined, storySetting, ...restParam } = params;
+
+  return {
+    ...restParam,
+    // Repack community payload by mapping postSetting to the actual value.
+    ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+    // Convert story setting to the actual value. (Allow by default)
+    allowCommentInStory:
+      typeof storySetting?.enableComment === 'boolean' ? storySetting.enableComment : true,
+  };
+};
+
+export const prepareSemanticSearchCommunityPayload = ({
+  searchResult,
+  ...communityPayload
+}: Amity.SemanticSearchCommunityPayload): Amity.ProcessedSemanticSearchCommunityPayload => {
+  const processedCommunityPayload = prepareCommunityPayload(communityPayload);
+
+  return {
+    ...processedCommunityPayload,
+  };
+};

package/src/communityRepository/utils/saveCommunityUsers.ts

@@ -0,0 +1,16 @@
+import { pushToCache } from '~/cache/api';
+
+export const saveCommunityUsers = (
+  communities: Amity.CommunityPayload['communities'],
+  communityUsers: Amity.CommunityPayload['communityUsers'],
+) => {
+  if (communities.length === 0 || communityUsers.length === 0) return;
+
+  communities.forEach(({ communityId }) => {
+    const collection = communityUsers.filter(
+      ({ communityId: userCommunityId }) => communityId === userCommunityId,
+    );
+
+    pushToCache(['communityUsers', 'collection', communityId], collection);
+  });
+};

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,100 @@
+// TODO: find a way to uniquely identify the device
+// import { getStorage } from './storage'
+import { safeProcess } from '~/utils/env';
+import { VERSION } from '~/version';
+import * as localStorage from '../client/utils/localStorage';
+import { uuid } from './uuid';
+import { getActiveClient } from '~/client/api/activeClient';
+
+type CrossTabResponse = {
+  tabId: string;
+  type: 'startup' | 'identify';
+  tabIndex?: number;
+};
+
+let tabIndex = 0;
+
+// This logic is running on browser only
+if (typeof BroadcastChannel !== 'undefined' && typeof window !== 'undefined') {
+  const tabId = uuid();
+  const openedTabs: { [key: CrossTabResponse['tabId']]: CrossTabResponse['tabIndex'] } = {};
+  const internalBroadcast = new BroadcastChannel('amity_ts_sdk');
+  let debouceTimer: NodeJS.Timeout;
+
+  // Ask nearby opened tabs for indexing
+  internalBroadcast.postMessage({ type: 'startup', tabId });
+
+  internalBroadcast.onmessage = ({ data }: { data: CrossTabResponse }) => {
+    // Ignore messages from self
+    if (data.tabId === tabId) return;
+
+    if (data.type === 'startup') {
+      internalBroadcast.postMessage({ type: 'identify', tabId, tabIndex });
+    }
+
+    if (data.type === 'identify' && data.tabIndex !== undefined && data.tabId) {
+      openedTabs[data.tabId] = data.tabIndex;
+      if (!debouceTimer) {
+        debouceTimer = setTimeout(() => {
+          const sorted = Object.values(openedTabs).sort();
+          if (!sorted || sorted.length === 0) return;
+
+          // @ts-ignore
+          tabIndex = sorted.reduce((acc: number, currentIndex: number) => {
+            if (acc < currentIndex) {
+              return acc;
+            }
+
+            return currentIndex + 1;
+          }, 0);
+        }, 15);
+      }
+    }
+  };
+}
+
+/** @hidden */
+export const getDeviceId = async () => {
+  // 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
+
+  const client = getActiveClient();
+  const key = `${client.prefixDeviceIdKey ?? ''}#deviceId`;
+
+  const savedDeviceId = await localStorage.getItem(key);
+  if (savedDeviceId) return savedDeviceId;
+
+  const deviceId = `ascWebSdk#${uuid()}`;
+  await localStorage.setItem(key, deviceId);
+  return deviceId;
+};
+
+export const getMQTTClientId = async (userId: Amity.InternalUser['userId']) => {
+  const savedDeviceId = await getDeviceId();
+  return `mqttjs_${savedDeviceId}_${userId}_${tabIndex}`;
+};
+
+/** @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 {
+    // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
+    kind: 'web',
+    model,
+    sdkVersion: VERSION,
+  };
+};

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,129 @@
+/* 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',
+  'sessionStateChange',
+  // for internal use by accessTokenExpiryWatcher
+  'tokenExpired',
+] as const;
+
+const MQTT_EVENTS = [
+  'connect',
+  'message',
+  'disconnect',
+  'error',
+  'close',
+  'end',
+  'reconnect',
+
+  'video-streaming.didStart',
+  'video-streaming.didRecord',
+  'video-streaming.didStop',
+  'video-streaming.didFlag',
+  'video-streaming.didTerminate',
+
+  'video-streaming.viewerDidBan',
+  'video-streaming.viewerDidUnban',
+
+  'liveReaction.created',
+] as const;
+
+/** @hidden */
+export const createEventEmitter = () => {
+  return mitt<Amity.Events>();
+};
+
+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);
+
+    try {
+      fn(...payload);
+    } catch (e) {
+      log(`${namespace}(tmpid: ${timestamp}) > error`, e);
+    }
+  };
+
+  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/liveCollection/LiveCollectionController.ts

@@ -0,0 +1,145 @@
+import { convertGetterPropsToStatic, removeFunctionProperties } from '~/utils/object';
+import { isEqual } from '~/utils/isEqual';
+import { PaginationController } from './PaginationController';
+import { PaginationNoPageController } from './PaginationNoPageController';
+
+export abstract class LiveCollectionController<
+  TPayloadDomain extends keyof Amity.Payloads,
+  TQueryParams,
+  TPublicPayload extends Record<string, unknown>,
+  TPaginationController extends
+    | PaginationController<TPayloadDomain, TQueryParams>
+    | PaginationNoPageController<TPayloadDomain, TQueryParams>,
+> {
+  protected paginationController: TPaginationController;
+
+  protected queryStreamId: string;
+
+  protected cacheKey: string[];
+
+  protected callback: Amity.LiveCollectionCallback<TPublicPayload>;
+
+  protected snapshot: TPublicPayload[] | undefined;
+
+  constructor(
+    paginationController: TPaginationController,
+    queryStreamId: string,
+    cacheKey: string[],
+    callback: Amity.LiveCollectionCallback<TPublicPayload>,
+  ) {
+    this.paginationController = paginationController;
+    this.queryStreamId = queryStreamId;
+    this.cacheKey = cacheKey;
+    this.callback = callback;
+  }
+
+  private async refresh() {
+    try {
+      let result;
+
+      if (this.paginationController instanceof PaginationNoPageController) {
+        result = await this.paginationController.onFetch();
+      } else {
+        result = await this.paginationController.loadFirstPage();
+      }
+      if (!result) return;
+
+      await this.persistModel(result);
+
+      this.persistQueryStream({
+        response: result,
+        direction: Amity.LiveCollectionPageDirection.NEXT,
+        refresh: true,
+      });
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false });
+    } catch (e) {
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false, error: e });
+    }
+  }
+
+  protected loadPage({
+    initial = false,
+    direction = Amity.LiveCollectionPageDirection.NEXT,
+  }: {
+    initial?: boolean;
+    direction?: Amity.LiveCollectionPageDirection;
+  }) {
+    this.setup();
+
+    this.notifyChange({ origin: Amity.LiveDataOrigin.LOCAL, loading: true });
+
+    if (initial) {
+      this.refresh();
+    } else if (direction === Amity.LiveCollectionPageDirection.PREV) {
+      this.loadPrevPage();
+    } else if (direction === Amity.LiveCollectionPageDirection.NEXT) {
+      this.loadNextPage();
+    }
+  }
+
+  protected abstract setup(): void;
+
+  async loadNextPage() {
+    try {
+      if (this.paginationController instanceof PaginationNoPageController) return;
+
+      const result = await this.paginationController.loadNextPage();
+      if (!result) return;
+
+      await this.persistModel(result);
+
+      this.persistQueryStream({
+        response: result,
+        direction: Amity.LiveCollectionPageDirection.NEXT,
+      });
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false });
+    } catch (e) {
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false, error: e });
+    }
+  }
+
+  async loadPrevPage() {
+    try {
+      if (this.paginationController instanceof PaginationNoPageController) return;
+
+      const result = await this.paginationController.loadPreviousPage();
+      if (!result) return;
+
+      await this.persistModel(result);
+
+      this.persistQueryStream({
+        response: result,
+        direction: Amity.LiveCollectionPageDirection.PREV,
+      });
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false });
+    } catch (e) {
+      this.notifyChange({ origin: Amity.LiveDataOrigin.SERVER, loading: false, error: e });
+    }
+  }
+
+  protected abstract persistModel(
+    response: Amity.Payloads[TPayloadDomain] & Partial<Amity.Pagination>,
+  ): Promise<void> | void;
+
+  protected abstract persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<TPayloadDomain>): void;
+
+  abstract startSubscription(): Amity.Unsubscriber[];
+
+  abstract notifyChange(params: Amity.LiveCollectionNotifyParams): void;
+
+  protected shouldNotify(data: TPublicPayload[]) {
+    const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
+    if (isEqual(this.snapshot, newData)) return false;
+
+    this.snapshot = newData as TPublicPayload[];
+    return true;
+  }
+
+  public getCacheKey() {
+    return this.cacheKey;
+  }
+}