@bugfender/rn-bugfender 1.1.3 → 2.0.0-alpha.0

package/src/bugfender.ts

@@ -0,0 +1,360 @@
+import { NativeModules, Platform } from 'react-native';
+import type { ISDKOptions } from './types/sdk-options';
+import type { UserFeedbackOptions, UserFeedbackResult } from './user-feedback';
+import { DefaultUserFeedbackOptions } from './user-feedback';
+import type { DeviceKeyValue } from './types/device';
+import type { ILogEntry } from './types/log';
+import { StringFormatter } from './string-formatter';
+import { LogLevel } from "./types/log";
+import { OverrideConsoleMethods } from "./override-console-methods";
+import { PrintToConsole } from "./print-to-console";
+import { SDKOptions } from "./sdk-options";
+
+const LINKING_ERROR =
+  `The package '@bugfender/rn-bugfender' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo managed workflow\n';
+
+const RnBugfender = NativeModules.RnBugfender
+  ? NativeModules.RnBugfender
+  : new Proxy(
+    {},
+    {
+      get() {
+        throw new Error(LINKING_ERROR);
+      },
+    }
+  );
+
+class BugfenderClass {
+  private stringFormatter = new StringFormatter();
+  private overrideConsoleMethods = new OverrideConsoleMethods(window);
+  private printToConsole = new PrintToConsole(global.console);
+  private sdkOptions: SDKOptions = new SDKOptions();
+  private initialized = false;
+
+  public async init(options: ISDKOptions): Promise<void> {
+    if (!this.initialized) {
+      const validatedOptions = this.sdkOptions.init(options);
+
+      // Needs to be executed prior initialization
+      if (typeof options.deviceName !== 'undefined') {
+        RnBugfender.overrideDeviceName(options.deviceName);
+      }
+
+      // Library initialization
+      Platform.OS === 'ios'
+        ? RnBugfender.activateLogger(validatedOptions.appKey)
+        : RnBugfender.init(validatedOptions.appKey, false);
+
+      if (typeof validatedOptions.apiURL !== 'undefined') {
+        RnBugfender.setApiUrl(validatedOptions.apiURL);
+      }
+
+      if (typeof validatedOptions.baseURL !== 'undefined') {
+        RnBugfender.setBaseUrl(validatedOptions.baseURL);
+      }
+
+      if (validatedOptions.enableLogcatLogging) {
+        RnBugfender.enableLogcatLogging();
+      }
+
+      if (validatedOptions.logUIEvents) {
+        RnBugfender.enableUIEventLogging();
+      }
+
+      if (validatedOptions.registerErrorHandler) {
+        RnBugfender.enableCrashReporting();
+      }
+
+      if (validatedOptions.overrideConsoleMethods) {
+        this.overrideConsoleMethods.init(this.stringFormatter);
+      }
+
+      this.printToConsole.init(validatedOptions.printToConsole ?? true);
+
+      this.initialized = true;
+    }
+  }
+
+  /**
+   * @returns Bugfender dashboard URL for the device
+   */
+  public getDeviceURL(): Promise<string> {
+    return RnBugfender.getDeviceUrl();
+  }
+
+  /**
+   * @returns Bugfender dashboard URL for the current session
+   */
+  public getSessionURL(): Promise<string> {
+    return RnBugfender.getSessionUrl();
+  }
+
+  /**
+   * Show a modal which asks for feedback. Once the user closes the modal or sends the feedback
+   * the returned promise resolves with the result.
+   *
+   * ```typescript
+   * Bugfender.getUserFeedback().then((result) => {
+   *     if (result.isSent) {
+   *         // User sent the feedback
+   *         // `result.feedbackURL` contains the Bugfender feedback URL
+   *     } else {
+   *         // User closed the modal without sending the feedback
+   *     }
+   * });
+   * ```
+   *
+   * @param options Options object to configure modal strings
+   * @returns Promise which resolves once the user closes the modal or sends the feedback
+   */
+  public async getUserFeedback(
+    options?: UserFeedbackOptions
+  ): Promise<UserFeedbackResult> {
+    return new Promise<UserFeedbackResult>((resolve) => {
+      options = {
+        ...new DefaultUserFeedbackOptions(),
+        ...(options ?? {}),
+      };
+
+      return RnBugfender.showUserFeedback(
+        options.title,
+        options.hint,
+        options.subjectPlaceholder,
+        options.feedbackPlaceholder,
+        options.submitLabel,
+        options.closeLabel
+      ).then(
+        (value: string) => {
+          resolve({
+            isSent: true,
+            feedbackURL: value,
+          });
+        },
+        (_: any) => {
+          resolve({
+            isSent: false,
+          });
+        }
+      );
+    });
+  }
+
+  /**
+   * @param obj A JavaScript value to output
+   * @param objs List of optional JavaScript values to output
+   */
+  public log(obj: unknown, ...objs: unknown[]): void;
+  /**
+   * String message with optional substitutions. This mimicks que the `window.console` template messages. [Learn more in MDN](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+   *
+   * @param msg Message with optional `%` placeholders
+   * @param subst Optional substitutions list
+   */
+  public log(msg: string, ...subst: unknown[]): void;
+  public log(...parameters: unknown[]): void {
+    this.printToConsole.log(...parameters);
+
+    let message = this.stringFormatter.format([...parameters]);
+    RnBugfender.debug('', message);
+  }
+
+  /**
+   * @param obj A JavaScript value to output
+   * @param objs List of optional JavaScript values to output
+   */
+  public warn(obj: unknown, ...objs: unknown[]): void;
+  /**
+   * String message with optional substitutions. This mimicks que the `window.console` template messages. [Learn more in MDN](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+   *
+   * @param msg Message with optional `%` placeholders
+   * @param subst Optional substitutions list
+   */
+  public warn(msg: string, ...subst: unknown[]): void;
+  public warn(...parameters: unknown[]): void {
+    this.printToConsole.warn(...parameters);
+
+    let message = this.stringFormatter.format([...parameters]);
+    RnBugfender.warning('', message);
+  }
+
+  /**
+   * @param obj A JavaScript value to output
+   * @param objs List of optional JavaScript values to output
+   */
+  public error(obj: unknown, ...objs: unknown[]): void;
+  /**
+   * String message with optional substitutions. This mimicks que the `window.console` template messages. [Learn more in MDN](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+   *
+   * @param msg Message with optional `%` placeholders
+   * @param subst Optional substitutions list
+   */
+  public error(msg: string, ...subst: unknown[]): void;
+  public error(...parameters: unknown[]): void {
+    this.printToConsole.error(...parameters);
+
+    let message = this.stringFormatter.format([...parameters]);
+    RnBugfender.error('', message);
+  }
+
+  /**
+   * @param obj A JavaScript value to output
+   * @param objs List of optional JavaScript values to output
+   */
+  public trace(obj: unknown, ...objs: unknown[]): void;
+  /**
+   * String message with optional substitutions. This mimicks que the `window.console` template messages. [Learn more in MDN](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+   *
+   * @param msg Message with optional `%` placeholders
+   * @param subst Optional substitutions list
+   */
+  public trace(msg: string, ...subst: unknown[]): void;
+  public trace(...parameters: unknown[]): void {
+    this.printToConsole.trace(...parameters);
+
+    let message = this.stringFormatter.format([...parameters]);
+    RnBugfender.trace('', message);
+  }
+
+  /**
+   * @param obj A JavaScript value to output
+   * @param objs List of optional JavaScript values to output
+   */
+  public info(obj: unknown, ...objs: unknown[]): void;
+  /**
+   * String message with optional substitutions. This mimicks que the `window.console` template messages. [Learn more in MDN](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+   *
+   * @param msg Message with optional `%` placeholders
+   * @param subst Optional substitutions list
+   */
+  public info(msg: string, ...subst: unknown[]): void;
+  public info(...parameters: unknown[]): void {
+    this.printToConsole.info(...parameters);
+
+    let message = this.stringFormatter.format([...parameters]);
+    RnBugfender.info('', message);
+  }
+
+  /**
+   * @param obj A JavaScript value to output
+   * @param objs List of optional JavaScript values to output
+   */
+  public fatal(obj: unknown, ...objs: unknown[]): void;
+  /**
+   * String message with optional substitutions. This mimicks que the `window.console` template messages. [Learn more in MDN](https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions).
+   *
+   * @param msg Message with optional `%` placeholders
+   * @param subst Optional substitutions list
+   */
+  public fatal(msg: string, ...subst: unknown[]): void;
+  public fatal(...parameters: unknown[]): void {
+    this.printToConsole.error(...parameters);
+
+    let message = this.stringFormatter.format([...parameters]);
+    RnBugfender.fatal('', message);
+  }
+
+  /**
+   * Remove a device associated key-value pair. [Learn more](https://bugfender.com/blog/associated-device-information/).
+   *
+   * @param key Key identifier
+   */
+  public removeDeviceKey(key: string): void {
+    RnBugfender.removeDeviceKey(key);
+    this.printToConsole.info(`Device key "${key}" removed`);
+  }
+
+  /**
+   * Use this method if you need more control over the data sent while logging. See `ILogEntry` interface reference to see all the accepted properties.
+   *
+   * @param log Log object that complies with `ILogEntry` interface.
+   */
+  public sendLog(log: ILogEntry): void {
+    this.printToConsole.printLog(log);
+
+    RnBugfender.log(
+      log.line ?? 0,
+      log.method ?? '',
+      log.file ?? '',
+      log.level ?? LogLevel.Debug,
+      log.tag ?? '',
+      log.text ?? ''
+    );
+  }
+
+  /**
+   * Send an issue.
+   *
+   * @param title - Title
+   * @param text - Text content
+   * @returns Bugfender dashboard URL for the issue.
+   */
+  public sendIssue(title: string, text: string): Promise<string> {
+    this.printToConsole.warn(`Issue: ${title}.\n${text}`);
+    return RnBugfender.sendIssue(title, text);
+  }
+
+  /**
+   * Send a crash report.
+   *
+   * @param title - Title
+   * @param text - Text content
+   * @returns Bugfender dashboard URL for the crash.
+   */
+  public sendCrash(title: string, text: string): Promise<string> {
+    this.printToConsole.error(`Crash: ${title}.\n${text}`);
+    return RnBugfender.sendCrash(title, text);
+  }
+
+  /**
+   * Send an user feedback.
+   *
+   * @param title - Title/Subject
+   * @param text - Feedback text
+   * @returns Bugfender dashboard URL for the feedback.
+   */
+  public sendUserFeedback(title: string, text: string): Promise<string> {
+    this.printToConsole.info(`User Feedback: ${title}.\n${text}`);
+    return RnBugfender.sendUserFeedback(title, text);
+  }
+
+  /**
+   * Set a device associated key-value pair. [Learn more](https://bugfender.com/blog/associated-device-information/).
+   *
+   * @param key Key identifier.
+   * @param value Value.
+   */
+  public setDeviceKey(key: string, value: DeviceKeyValue): void {
+    this.printToConsole.info(`Device key "${key}" set to "${value}"`);
+
+    if (typeof value === 'boolean') {
+      RnBugfender.setDeviceBoolean(key, value);
+    } else if (typeof value === 'string') {
+      RnBugfender.setDeviceString(key, value);
+    } else {
+      // typeof value === 'number'
+      if (Number.isInteger(value)) {
+        RnBugfender.setDeviceInteger(key, value);
+      } else {
+        RnBugfender.setDeviceFloat(key, value);
+      }
+    }
+  }
+
+  /**
+   * Synchronizes all logs and issues with the server once, regardless if this device is enabled or not.
+   *
+   * Logs and issues are synchronized only once. After that, the logs are again sent according to the enabled flag
+   * in the Bugfender Console.
+   */
+  public forceSendOnce(): void {
+    this.printToConsole.info(`Force send once`);
+    RnBugfender.forceSendOnce();
+  }
+}
+
+export {
+  BugfenderClass, RnBugfender
+}

package/src/index.tsx

@@ -0,0 +1,7 @@
+import { LogLevel } from './types/log';
+import { SDKOptionsBuilder } from './types/sdk-options';
+import { BugfenderClass } from './bugfender';
+
+const Bugfender = new BugfenderClass();
+
+export { Bugfender, LogLevel, SDKOptionsBuilder };

package/src/index.web.tsx

@@ -0,0 +1,5 @@
+import { LogLevel } from './types/log';
+import { SDKOptionsBuilder } from './types/sdk-options';
+import { Bugfender } from '@bugfender/sdk';
+
+export { Bugfender, LogLevel, SDKOptionsBuilder };

package/src/override-console-methods.ts

@@ -0,0 +1,53 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {RnBugfender} from "./bugfender";
+import type {StringFormatter} from "./string-formatter";
+
+/**
+ * Overrides the `window.console` methods in order to execute the Bugfender equivalent logging
+ * methods while keeping the original browser functionality.
+ */
+export class OverrideConsoleMethods {
+  constructor(
+    protected window: Window,
+  ) {
+  }
+
+  public init(stringFormatter: StringFormatter): void {
+
+    (this.window as any).console = function (console: Console) {
+      return {
+        ...console,
+        log: function (...parameters: unknown[]) {
+          console.log(...parameters);
+          let message = stringFormatter.format([...parameters]);
+          RnBugfender.debug('', message);
+        },
+        debug: function (...parameters: unknown[]) {
+          console.debug(...parameters);
+          let message = stringFormatter.format([...parameters]);
+          RnBugfender.debug('', message);
+        },
+        trace: function (...parameters: unknown[]) {
+          console.trace(...parameters);
+          let message = stringFormatter.format([...parameters]);
+          RnBugfender.trace('', message);
+        },
+        info: function (...parameters: unknown[]) {
+          console.info(...parameters);
+          let message = stringFormatter.format([...parameters]);
+          RnBugfender.info('', message);
+        },
+        warn: function (...parameters: unknown[]) {
+          console.warn(...parameters);
+          let message = stringFormatter.format([...parameters]);
+          RnBugfender.warning('', message);
+        },
+        error: function (...parameters: unknown[]) {
+          console.error(...parameters);
+          let message = stringFormatter.format([...parameters]);
+          RnBugfender.error('', message);
+        },
+      };
+    }((this.window as any).console);
+  }
+}

package/src/print-to-console.ts

@@ -0,0 +1,67 @@
+import {format} from 'util';
+import type {ILogEntry} from "./types/log";
+import {LogLevel} from "./types/log";
+
+export class PrintToConsole {
+  protected printToConsole: boolean = false;
+
+  constructor(
+    protected readonly console: Console,
+  ) {
+  }
+
+  public init(printToConsole: boolean): void {
+    this.printToConsole = printToConsole;
+  }
+
+  public error(...parameters: unknown[]): void {
+    if (this.printToConsole) {
+      this.console.error(...parameters);
+    }
+  }
+
+  public info(...parameters: unknown[]): void {
+    if (this.printToConsole) {
+      this.console.info(...parameters);
+    }
+  }
+
+  public log(...parameters: unknown[]): void {
+    if (this.printToConsole) {
+      this.console.log(...parameters);
+    }
+  }
+
+  public debug(...parameters: unknown[]): void {
+    if (this.printToConsole) {
+      this.console.debug(...parameters);
+    }
+  }
+
+  public trace(...parameters: unknown[]): void {
+    if (this.printToConsole) {
+      this.console.trace(...parameters);
+    }
+  }
+
+  public warn(...parameters: unknown[]): void {
+    if (this.printToConsole) {
+      this.console.warn(...parameters);
+    }
+  }
+
+  public printLog(log: ILogEntry): void {
+    if (this.printToConsole) {
+      // Log to browser console
+      // debug, warning, error, trace, info, fatal
+      const levelToMethod = ['log', 'warn', 'error', 'trace', 'info', 'error'];
+      const method = levelToMethod[log.level || LogLevel.Debug];
+      const tag = log.tag ? `[${log.tag}] ` : '';
+      const location = [log.file || '', log.method || '', log.line || ''].filter(p => p !== '').join(':');
+      const message = `${tag}${format(log.text)} ${location}`;
+
+      // @ts-ignore
+      this.console[method](message);
+    }
+  }
+}

package/src/sdk-options.ts

@@ -0,0 +1,68 @@
+import type {ISDKOptions} from "./types/sdk-options";
+
+export class SDKOptions {
+  protected rules = {
+    appKey: ['required', 'string'],
+    apiURL: ['string', 'url'],
+    baseURL: ['string', 'url'],
+    overrideConsoleMethods: ['boolean'],
+    printToConsole: ['boolean'],
+    logBrowserEvents: ['boolean'],
+    logUIEvents: ['boolean'],
+    registerErrorHandler: ['boolean'],
+    version: ['string'],
+  };
+
+  public init(options: ISDKOptions): ISDKOptions {
+    // Validate user provided options
+    this.validate(options);
+
+    // Removing undefined attributes
+    options = { ...options };
+    Object.entries(options).forEach(([key, value]) => {
+      if (value === undefined) {
+        // @ts-ignore
+        delete options[key];
+      }
+    });
+
+    // Set default values if needed
+    return {
+      overrideConsoleMethods: true,
+      printToConsole: true,
+      logUIEvents: true,
+      registerErrorHandler: true,
+      enableLogcatLogging: false,
+      ...options,
+    };
+  }
+
+  protected validate(options: ISDKOptions): void {
+    const urlValidator = new RegExp(/^http(s)?:\/\//i);
+
+    Object.entries(this.rules).forEach(([key, rules]) => {
+      // @ts-ignore
+      const value = options[key];
+
+      rules.forEach(rule => {
+        if (rule === 'required') {
+          if (typeof value === 'undefined') {
+            throw new Error(`Bugfender requires '${key}' option to initialize.`)
+          }
+        } else if (rule === 'string') {
+          if (!['string', 'undefined'].includes(typeof value)) {
+            throw new Error(`'${key}' option must be a string.`);
+          }
+        } else if (rule === 'url') {
+          if (typeof value !== 'undefined' && !urlValidator.test(value)) {
+            throw new Error(`'${key}' option must be a valid URL.`);
+          }
+        } else if (rule === 'boolean') {
+          if (!['boolean', 'undefined'].includes(typeof value)) {
+            throw new Error(`'${key}' option must be a boolean.`);
+          }
+        }
+      })
+    });
+  }
+}

package/src/string-formatter.ts

@@ -0,0 +1,44 @@
+import {format} from "util";
+
+export class StringFormatter {
+  public format(parameters: unknown[]): string {
+    const [, ...textParams] = parameters;
+    let [textFormat] = parameters as string[];
+    let text: string;
+
+    try {
+      // Our sanitizer gives better results, try with it first
+      textFormat = this.toString(textFormat);
+    } catch {
+      // Fallback to `format`
+      textFormat = format(textFormat);
+    }
+
+    if (textParams.length > 0) {
+      text = format(textFormat, ...textParams);
+    } else {
+      text = textFormat;
+    }
+
+    return text;
+  }
+
+  private toString(value: unknown): string {
+    // Depending on the type we prefer to do `String` or `stringify`
+    const isToString = ['string', 'symbol', 'bigint', 'function'].includes(typeof value) || value instanceof Error;
+
+    if (isToString) {
+      try {
+        return String(value);
+      } catch {
+        return JSON.stringify(value);
+      }
+    } else {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    }
+  }
+}

package/src/types/device.ts

@@ -0,0 +1,4 @@
+/**
+ * Device Key Value
+ */
+export type DeviceKeyValue = string | number | boolean;

package/src/types/log.ts

@@ -0,0 +1,75 @@
+/**
+ * Log Levels
+ *
+ * Check the main README to see how to access the `LogLevel` enum.
+ */
+export enum LogLevel {
+  Debug = 0,
+  Warning = 1,
+  Error = 2,
+  Trace = 3,
+  Info = 4,
+  Fatal = 5,
+}
+
+/**
+ * @hidden
+ */
+export const LOG_LEVELS: LogLevel[] = [
+  LogLevel.Debug,
+  LogLevel.Warning,
+  LogLevel.Error,
+  LogLevel.Trace,
+  LogLevel.Info,
+  LogLevel.Fatal,
+];
+
+/**
+ * @hidden
+ */
+export interface ILogEntryShort {
+  /** Date ISO */
+  x: string;
+  /** Text */
+  t: string;
+  /** Method */
+  m: string;
+  /** Absolute Time */
+  at: number;
+  /** Tag */
+  tg: string;
+  /** File */
+  f: string;
+  /** Line */
+  l: number;
+  /** Level */
+  ll: number;
+  /** URL */
+  u: string;
+}
+
+/**
+ * Log Entry object interface
+ */
+export interface ILogEntry {
+  /** The line number where the log was triggered from */
+  line?: number;
+
+  /** The log's level based on LogLevel constant */
+  level?: LogLevel;
+
+  /** The log's tag */
+  tag?: string;
+
+  /** The method name where the log was triggered from */
+  method?: string;
+
+  /** The file name where the log was triggered from */
+  file?: string;
+
+  /** The log's text content */
+  text?: string;
+
+  /** The log's origin URL. This attribute is ignored on Android & iOS */
+  url?: string;
+}