@creator.co/wapi 1.2.4 → 1.2.6

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**'
         })

package/src/Mailer/Mailer.ts

@@ -4,48 +4,30 @@ import * as Email from 'email-templates'
 import * as nodemailer from 'nodemailer'
 import type * as SESTransport from 'nodemailer/lib/ses-transport'
 
-/**
- * ${1:Description placeholder}
- *
- * @export
- * @class Mailer
- * @typedef {Mailer}
- */
 export default class Mailer {
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @readonly
+   * The starting point of a range.
    * @type {string}
    */
   private readonly from: string
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @readonly
+   * The default file template for the application.
    * @type {string}
    */
   private readonly templateDefaultFile: string = 'html'
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @readonly
-   * @type {ReturnType<
-   *     typeof nodemailer.createTransport<SESTransport.SentMessageInfo>
-   *   >}
+   * The transporter object used for sending emails using the AWS SES service.
+   * @type {ReturnType<typeof nodemailer.createTransport<SESTransport.SentMessageInfo>>}
    */
   private readonly transporter: ReturnType<
     typeof nodemailer.createTransport<SESTransport.SentMessageInfo>
   >
+
   /**
-   * Creates an instance of Mailer.
-   *
-   * @constructor
-   * @param {string} defaultFrom
-   * @param {string} region
+   * Constructs a new instance of the EmailSender class.
+   * @param {string} defaultFrom - The default "from" email address.
+   * @param {string} region - The AWS region to use for sending emails.
+   * @returns None
    */
   constructor(defaultFrom: string, region: string) {
     this.from = defaultFrom
@@ -62,19 +44,14 @@ export default class Mailer {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {(string | Array<string>)} to
-   * @param {string} htmlMessage
-   * @param {string} subject
-   * @param {?(string | Array<string>)} [optionalCC]
-   * @param {?string} [optionalFrom]
-   * @param {?string} [optionalReplyTo]
-   * @param {?any[]} [optionalAttachments]
-   * @param {?Email.NodeMailerTransportOptions} [optionalTransport]
-   * @returns {unknown}
+   * Sends a raw email with the specified parameters.
+   * @param {string | Array<string>} to - The recipient(s) of the email.
+   * @param {string} htmlMessage - The HTML content of the email.
+   * @param {string} subject - The subject of the email.
+   * @param {string | Array<string>} [optionalCC] - The optional CC recipient(s) of the email.
+   * @param {string} [optionalFrom] - The optional sender of the email. If not provided, the default sender will be used.
+   * @param {string} [optionalReplyTo] - The optional reply-to address for the email.
+   * @param {any[]} [optionalAttachments] - The optional attachments to include
    */
   public async sendRawEmail(
     to: string | Array<string>,
@@ -112,20 +89,16 @@ export default class Mailer {
     }
     return resp
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {(string | Array<string>)} to
-   * @param {(string | Array<string>)} templates
-   * @param {object} data
-   * @param {?(string | Array<string>)} [optionalCC]
-   * @param {?string} [optionalFrom]
-   * @param {?string} [optionalReplyTo]
-   * @param {?any[]} [optionalAttachments]
-   * @param {?Email.NodeMailerTransportOptions} [optionalTransport]
-   * @returns {unknown}
+   * Sends a templated email to the specified recipients.
+   * @param {string | Array<string>} to - The email address(es) of the recipient(s).
+   * @param {string | Array<string>} templates - The template(s) to use for the email.
+   * @param {object} data - The data to be used in the email template.
+   * @param {string | Array<string>} [optionalCC] - The email address(es) to CC.
+   * @param {string} [optionalFrom] - The email address to send the email from.
+   * @param {string} [optionalReplyTo] - The email address to set as the reply-to address.
+   * @param {any[]} [optionalAttachments] - An array
    */
   public async sendTemplatedEmail(
     to: string | Array<string>,
@@ -162,15 +135,14 @@ export default class Mailer {
     }
     return resp
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {string} host
-   * @param {number} portNumber
-   * @param {string} user
-   * @param {string} password
-   * @returns {Email.NodeMailerTransportOptions}
+   * Creates a new SMTP transporter for sending emails using NodeMailer.
+   * @param {string} host - The SMTP server host.
+   * @param {number} portNumber - The port number to connect to the SMTP server.
+   * @param {string} user - The username for authentication with the SMTP server.
+   * @param {string} password - The password for authentication with the SMTP server.
+   * @returns {Email.NodeMailerTransportOptions} - The SMTP transporter object.
    */
   public newSMTPTransporter(
     host: string,
@@ -190,15 +162,12 @@ export default class Mailer {
     return smtpTransporter
   }
 
-  /* private */
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @async
-   * @param {(string | Array<string>)} templates
-   * @param {object} data
-   * @returns {Promise<string>}
+   * Chooses a template from the given array of templates or a single template string based on whether it can be rendered with the provided data.
+   * @param {string | Array<string>} templates - The template(s) to choose from.
+   * @param {object} data - The data to be used for rendering the template.
+   * @returns {Promise<string>} - The chosen template.
+   * @throws {Error} - If no template can be rendered with the provided data.
    */
   private async chooseTemplate(templates: string | Array<string>, data: object): Promise<string> {
     if (Array.isArray(templates)) {
@@ -214,14 +183,12 @@ export default class Mailer {
         JSON.stringify(data, null, 2)
     )
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @async
-   * @param {string} template
-   * @param {object} data
-   * @returns {Promise<boolean>}
+   * Checks if a given email template can be rendered with the provided data.
+   * @param {string} template - The name of the email template.
+   * @param {object} data - The data to be used for rendering the template.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the template can be rendered, false otherwise.
    */
   private async canRenderTemplate(template: string, data: object): Promise<boolean> {
     let validRenderResp = null