@creator.co/wapi 1.2.5 → 1.2.6

package/src/Globals.ts

@@ -4,168 +4,100 @@ import Utils from './API/Utils'
 
 // important for dev env to load .env file
 dotenv.config()
+
 /**
- * Description placeholder
- *
- * @export
- * @class Globals
- * @typedef {Globals}
+ * Class containing global constants and configurations for the application.
  */
 export default class Globals {
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * A constant string representing an error message for input validation failure.
    */
   public static ErrorResponseValidationFail = 'Input validation failed: ' //400
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * A constant string representing an error response for an invalid server response.
    */
   public static ErrorResponseInvalidServerResponse = 'No valid response, this is a system error.' //400
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * The error message for an unhandled error when processing a request.
    */
   public static ErrorResponseUnhandledError = 'Unhandled error when processing request.' //400
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * A static string representing an error response when there are no records to be processed.
    */
   public static ErrorResponseNoRecords = 'No events to be processed.' //400
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
+   * Represents an error code for a missing parameter.
    * @type {string}
    */
   public static ErrorCode_MissingParam = 'MISSING_PARAM'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
+   * Represents an error code for invalid input.
    * @type {string}
    */
   public static ErrorCode_InvalidInput = 'INVALID_INPUT'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
+   * Represents an error code for an API error.
    * @type {string}
    */
   public static ErrorCode_APIError = 'API_ERROR'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
+   * Represents the error code for when there are no records found.
    * @type {string}
    */
   public static ErrorCode_NoRecords = 'EMPTY_EVENT'
 
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {*}
+   * Retrieves the default port number for HTTP listeners.
+   * The port number is obtained from the environment variable "PORT" and parsed as an integer.
+   * If the environment variable is not set or cannot be parsed as an integer, the default port number 9000 is used.
+   * @returns {number} - The default port number for HTTP listeners.
    */
   public static Listener_HTTP_DefaultPort = Utils.parseIntNullIfNaN(process.env.PORT) || 9000
-
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * The default host for the HTTP listener.
    */
   public static Listener_HTTP_DefaultHost = 'localhost'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
+   * The HTTP proxy route listener for all routes.
    * @type {string}
    */
   public static Listener_HTTP_ProxyRoute = '*'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {*}
+   * Retrieves the default timeout value for HTTP listeners.
+   * @returns {number} The default timeout value in milliseconds.
    */
   public static Listener_HTTP_DefaultTimeout = Utils.parseIntNullIfNaN(process.env.TIMEOUT) || 30000
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {*}
+   * The default health check route for the HTTP listener.
+   * @type {string}
    */
   public static Listener_HTTP_DefaultHealthCheckRoute = process.env.HEALTH_ROUTE || '/health'
-  //Resps
+
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * The response message for an exception that occurred during request execution in the Proxy.
    */
   public static Resp_MSG_EXCEPTION = '[Proxy]: Exception during request execution!'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * The response code for an exception that occurred during execution.
    */
   public static Resp_CODE_EXCEPTION = 'EXEC_EXCEPTION'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {number}
+   * The HTTP response status code for an exception scenario.
    */
   public static Resp_STATUSCODE_EXCEPTION = 502
 
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * The error message for an invalid response from the server.
    */
   public static Resp_MSG_INVALIDRESP = '[Proxy]: Invalid response from server!'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
-   * @type {string}
+   * Represents the response code for an invalid response.
    */
   public static Resp_CODE_INVALIDRESP = 'EMPTY_RESPONSE'
   /**
-   * Description placeholder
-   *
-   * @public
-   * @static
+   * The HTTP response status code for an invalid response.
    * @type {number}
+   * @default 400
    */
   public static Resp_STATUSCODE_INVALIDRESP = 400
 }

package/src/Logger/Logger.ts

@@ -2,14 +2,15 @@ import * as abind from 'abind'
 import * as stringify from 'json-stringify-safe'
 import * as stackTrace from 'stack-trace'
 
-//
 import Utils from '../API/Utils'
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @enum {number}
+ * Enumeration of log levels.
+ * @enum {string}
+ * @property {string} DEBUG - Debug log level.
+ * @property {string} INFO - Info log level.
+ * @property {string} WARN - Warning log level.
+ * @property {string} ERROR - Error log level.
  */
 export enum LOG_LEVELS {
   DEBUG = 'DEBUG',
@@ -18,22 +19,22 @@ export enum LOG_LEVELS {
   ERROR = 'ERROR',
 }
 /**
- * ${1:Description placeholder}
- *
- * @type {*}
+ * A constant that represents the console object to be used for logging.
+ * If the console object has a property named 'notGlobalLogger', it is assumed
+ * to be a custom logger and the 'origin' property is used as the console object.
+ * Otherwise, the global console object is used.
+ * @type {Console}
  */
 const PURE_CONSOLE = console['notGlobalLogger'] ? console['origin'] : console
 /**
- * ${1:Description placeholder}
- *
- * @type {*}
+ * The default log function that is used for logging messages.
+ * @type {Function}
  */
 const DEFAULT_LOG_FUNCTION = PURE_CONSOLE.log.bind(PURE_CONSOLE)
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @type {{}\}
+ * An array of sensitive strings that should be blacklisted or excluded from certain operations.
+ * This array includes strings such as 'password', 'phonenumber', 'resetCode', etc.
  */
 const blacklist = [
   'password',
@@ -49,206 +50,191 @@ const blacklist = [
   'UserCode',
   'paymentMethodNonce',
 ]
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @typedef {LoggerConfig}
+ * Configuration options for the logger.
+ * @typedef {Object} LoggerConfig
+ * @property {boolean | Array<string>} [sensitiveFilteringKeywords] - Specifies whether to filter sensitive keywords in log messages. Can be a boolean value or an array of strings.
+ * @property {LOG_LEVELS | string} [logLevel] - The log level to use for logging. Can be one of the predefined log levels or a custom string value.
  */
 export type LoggerConfig = {
   sensitiveFilteringKeywords?: boolean | Array<string>
   logLevel?: LOG_LEVELS | string
 }
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Logger
- * @typedef {Logger}
+ * Logger class for logging messages with different log levels.
  */
 export default class Logger {
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @type {?LoggerConfig}
+   * The optional configuration object for the logger.
    */
-  private _config?: LoggerConfig
+  private config?: LoggerConfig
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
+   * Private property representing the transaction ID.
    * @type {string}
+   * @private
    */
-  private _transactionID: string
+  private transactionID: string
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @type {(Array<string> | false)}
+   * An array of strings representing a blacklist of filters, or false if no blacklist is set.
    */
-  private _filterBlacklist: Array<string> | false
+  private filterBlacklist: Array<string> | false
   /**
-   * ${1:Description placeholder}
-   *
+   * The current log level for the application.
    * @private
    * @type {LOG_LEVELS}
    */
   private _LOG_LEVEL: LOG_LEVELS
   /**
-   * ${1:Description placeholder}
-   *
+   * The origin of the object.
    * @private
-   * @type {*}
+   * @type {any}
    */
   private origin: any
 
   /**
-   * Creates an instance of Logger.
-   *
-   * @constructor
-   * @param {(LoggerConfig | undefined)} _config
-   * @param {string} transactionID
+   * Constructs a Logger object with the given configuration and transaction ID.
+   * @param {config} config - The configuration object for the logger. Can be undefined.
+   * @param {string} transactionID - The ID of the transaction associated with the logger.
+   * @returns None
    */
-  constructor(_config: LoggerConfig | undefined, transactionID: string) {
+  constructor(config: LoggerConfig | undefined, transactionID: string) {
     abind(this)
     //
     this.origin = PURE_CONSOLE
-    this._LOG_LEVEL = _config?.logLevel
-      ? LOG_LEVELS[_config?.logLevel] || LOG_LEVELS.DEBUG
+    this._LOG_LEVEL = config?.logLevel
+      ? LOG_LEVELS[config?.logLevel] || LOG_LEVELS.DEBUG
       : LOG_LEVELS.DEBUG
-    this._config = _config || {}
-    this._transactionID = transactionID
-    this._filterBlacklist = this._config.sensitiveFilteringKeywords
-      ? Array.isArray(this._config.sensitiveFilteringKeywords)
-        ? this._config.sensitiveFilteringKeywords
+    this.config = config || {}
+    this.transactionID = transactionID
+    this.filterBlacklist = this.config.sensitiveFilteringKeywords
+      ? Array.isArray(this.config.sensitiveFilteringKeywords)
+        ? this.config.sensitiveFilteringKeywords
         : blacklist
       : false
     //
-    this._setupBindings()
+    this.setupBindings()
     //
     this.log('Using logger with level: ' + this._LOG_LEVEL.toString())
-    this.debug('logger config: ', this._config)
+    this.debug('logger config: ', this.config)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @returns {boolean}
+   * Returns a boolean value indicating whether the notGlobalLogger function is executed successfully.
+   * @returns {boolean} - true if the function is executed successfully, false otherwise.
    */
   public notGlobalLogger() {
     return true
   }
 
-  //Public
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {...{}\} args
+   * Logs the given arguments with the debug log level.
+   * @param {...any} args - The arguments to be logged.
+   * @returns None
    */
   debug(...args) {
-    this._processLog(LOG_LEVELS.DEBUG, args)
+    this.processLog(LOG_LEVELS.DEBUG, args)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {...{}\} args
+   * Logs the given arguments with the INFO log level.
+   * @param {...any} args - The arguments to be logged.
+   * @returns None
    */
   log(...args) {
-    this._processLog(LOG_LEVELS.INFO, args)
+    this.processLog(LOG_LEVELS.INFO, args)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {...{}\} args
+   * Logs an informational message.
+   * @param {...any} args - The message(s) to log.
+   * @returns None
    */
   info(...args) {
-    this._processLog(LOG_LEVELS.INFO, args)
+    this.processLog(LOG_LEVELS.INFO, args)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {...{}\} args
+   * Logs a warning message with the provided arguments.
+   * @param {...any} args - The arguments to be logged as a warning message.
+   * @returns None
    */
   warning(...args) {
-    this._processLog(LOG_LEVELS.WARN, args)
+    this.processLog(LOG_LEVELS.WARN, args)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {...{}\} args
+   * Logs a warning message to the console.
+   * @param {...any} args - The arguments to be logged.
+   * @returns None
    */
   warn(...args) {
-    this._processLog(LOG_LEVELS.WARN, args)
+    this.processLog(LOG_LEVELS.WARN, args)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {...{}\} args
+   * Logs an error message with the given arguments.
+   * @param {...any} args - The arguments to log as an error message.
+   * @returns None
    */
   error(...args) {
-    this._processLog(LOG_LEVELS.ERROR, args)
+    this.processLog(LOG_LEVELS.ERROR, args)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @param {*} exception
-   * @param {...{}\} args
+   * Logs an exception with optional additional arguments.
+   * @param {any} exception - The exception to log.
+   * @param {...any} args - Additional arguments to include in the log.
+   * @returns None
    */
   exception(exception, ...args) {
-    this._exception(exception, args)
+    this.iexception(exception, args)
   }
 
-  //initialization
   /**
-   * ${1:Description placeholder}
-   *
+   * Sets up the console bindings for logging purposes.
    * @private
+   * @returns None
    */
-  private _setupBindings(): void {
+  private setupBindings(): void {
     global.console = {
-      debug: (...args) => this._processLog(LOG_LEVELS.DEBUG, args),
-      log: (...args) => this._processLog(LOG_LEVELS.INFO, args),
-      info: (...args) => this._processLog(LOG_LEVELS.INFO, args),
-      warn: (...args) => this._processLog(LOG_LEVELS.WARN, args),
-      error: (...args) => this._processLog(LOG_LEVELS.ERROR, args),
+      debug: (...args) => this.processLog(LOG_LEVELS.DEBUG, args),
+      log: (...args) => this.processLog(LOG_LEVELS.INFO, args),
+      info: (...args) => this.processLog(LOG_LEVELS.INFO, args),
+      warn: (...args) => this.processLog(LOG_LEVELS.WARN, args),
+      error: (...args) => this.processLog(LOG_LEVELS.ERROR, args),
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
-      warning: (...args) => this._processLog(LOG_LEVELS.WARN, args),
-      exception: (exception, ...args) => this._exception(exception, args),
+      warning: (...args) => this.processLog(LOG_LEVELS.WARN, args),
+      exception: (exception, ...args) => this.iexception(exception, args),
     }
   }
 
-  /* Formatters */
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {LOG_LEVELS} level
-   * @param {Array<string>} msg
-   * @param {string} caller
-   * @returns {string}
+   * Formats a log message with the specified log level, message, and caller.
+   * @param {LOG_LEVELS} level - The log level of the message.
+   * @param {Array<string>} msg - An array of strings representing the message.
+   * @param {string} caller - The name of the caller function.
+   * @returns {string} - The formatted log message.
    */
-  private _formattedLog(level: LOG_LEVELS, msg: Array<string>, caller: string): string {
-    if (Utils.isHybridlessContainer() && this._transactionID) {
+  private formattedLog(level: LOG_LEVELS, msg: Array<string>, caller: string): string {
+    if (Utils.isHybridlessContainer() && this.transactionID) {
       return (
-        `${this._transactionID}` +
-        ` [${level.toString()}] [${caller}] ${msg.map(this._suppressSensitiveInfo).join(' ')}`
+        `${this.transactionID}` +
+        ` [${level.toString()}] [${caller}] ${msg.map(this.suppressSensitiveInfo).join(' ')}`
       )
     } else {
-      return `[${level.toString()}] [${caller}] ${msg.map(this._suppressSensitiveInfo).join(' ')}`
+      return `[${level.toString()}] [${caller}] ${msg.map(this.suppressSensitiveInfo).join(' ')}`
     }
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {number} index
-   * @returns {string}
+   * Returns the name of the caller at the specified index in the call stack.
+   * @param {number} index - The index of the caller in the call stack.
+   * @returns {string} The name of the caller, including the file name and line number.
    */
-  private _callerName(index: number): string {
+  private callerName(index: number): string {
     const safeIndex = Math.min(index, stackTrace.get().length)
     if (stackTrace.get()[safeIndex]) {
       let callerName = stackTrace.get()[safeIndex]
@@ -262,15 +248,14 @@ export default class Logger {
     }
     return ''
   }
-  /* Helpers (core functionality) */
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {LOG_LEVELS} level
-   * @param {*} args
+   * Processes a log message based on the specified log level and arguments.
+   * @param {LOG_LEVELS} level - The log level of the message.
+   * @param {any[]} args - The arguments to be logged.
+   * @returns None
    */
-  private _processLog(level: LOG_LEVELS, args: any): void {
+  private processLog(level: LOG_LEVELS, args: any): void {
     if (level < this._LOG_LEVEL) return
     //get args
     const msg: Array<string> = []
@@ -281,16 +266,16 @@ export default class Logger {
     }
     //push into logs stack
     // todo: improve error stack
-    this._pushLog(level, this._formattedLog(level, msg, this._callerName(3)))
+    this.pushLog(level, this.formattedLog(level, msg, this.callerName(3)))
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {Error} exception
-   * @param {...{}\} args
+   * Logs an exception along with additional arguments and the stack trace.
+   * @param {Error} exception - The exception object to log.
+   * @param {...any} args - Additional arguments to include in the log.
+   * @returns None
    */
-  private _exception(exception: Error, ...args): void {
+  private iexception(exception: Error, ...args): void {
     //format message
     const msg: Array<string> = []
     //push exeception
@@ -299,37 +284,33 @@ export default class Logger {
     for (const arg of args) if (arg != exception) msg.push(arg)
     if (exception.stack) msg.push(exception.stack) //push Exeception stack at the end
     //push into logs stack
-    this._pushLog(LOG_LEVELS.ERROR, this._formattedLog(LOG_LEVELS.ERROR, msg, this._callerName(3)))
+    this.pushLog(LOG_LEVELS.ERROR, this.formattedLog(LOG_LEVELS.ERROR, msg, this.callerName(3)))
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {LOG_LEVELS} level
-   * @param {string} fMsg
+   * Pushes a log message to the console with the specified log level.
+   * @param {LOG_LEVELS} level - The log level of the message.
+   * @param {string} fMsg - The formatted log message.
+   * @returns None
    */
-  private _pushLog(level: LOG_LEVELS, fMsg: string): void {
-    // push into logs stack
-    // this._logs.push(fMsg);
+  private pushLog(level: LOG_LEVELS, fMsg: string): void {
     DEFAULT_LOG_FUNCTION.apply(PURE_CONSOLE, [fMsg])
   }
-  /* Sensitive information handling */
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {*} value
-   * @returns {string}
+   * Suppresses sensitive information in the given value based on the filter blacklist.
+   * @param {any} value - The value to suppress sensitive information from.
+   * @returns {string} - The value with sensitive information suppressed.
    */
-  private _suppressSensitiveInfo(value: any): string {
+  private suppressSensitiveInfo(value: any): string {
     //realy false
-    if (!this._filterBlacklist) return value
+    if (!this.filterBlacklist) return value
     if (typeof value == 'string') {
       //content based replacement
-      if (this._filterBlacklist) {
-        this._filterBlacklist.forEach(() => {
-          const match = this._filterBlacklist
-            ? this._filterBlacklist.find(f => value.toLowerCase().includes(f.toLowerCase()))
+      if (this.filterBlacklist) {
+        this.filterBlacklist.forEach(() => {
+          const match = this.filterBlacklist
+            ? this.filterBlacklist.find(f => value.toLowerCase().includes(f.toLowerCase()))
             : false
           if (match) value = '**SUPPRESSED_SENSITIVE_DATA**'
         })