@ikonintegration/ikapi 4.0.1 → 5.0.0

package/src/Logger/Logger.ts

@@ -0,0 +1,363 @@
+import abind from 'abind'
+import stringify from 'json-stringify-safe'
+import stackTrace from 'stack-trace'
+
+import Utils from '../Util/Utils.js'
+
+/**
+ * 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',
+  INFO = 'INFO',
+  WARN = 'WARN',
+  ERROR = 'ERROR',
+}
+/**
+ * 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
+/**
+ * The default log function that is used for logging messages.
+ * @type {Function}
+ */
+const DEFAULT_LOG_FUNCTION = PURE_CONSOLE.log.bind(PURE_CONSOLE)
+
+/**
+ * Creates a blacklist array by mapping each string in the given array to its lowercase form.
+ * The resulting blacklist array is used to filter out sensitive information.
+ * @type {string[]} blacklist - An array of strings to be converted to lowercase and used as a blacklist.
+ * @returns {string[]} - An array of lowercase strings representing the blacklist.
+ */
+const blacklist = ['password', 'token', 'accounts', 'rawBody'].map(s => s.toLowerCase())
+
+/* Used to have a clean log */
+const defaultSuppress = ['rawBody'].map(s => s.toLowerCase())
+
+/**
+ * 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
+}
+
+type SupressableItem = {
+  value: any
+  parent: any
+  key: string | number
+}
+
+/**
+ * Logger class for logging messages with different log levels.
+ */
+export default class Logger {
+  /**
+   * The optional configuration object for the logger.
+   */
+  private config?: LoggerConfig
+  /**
+   * Private property representing the transaction ID.
+   * @type {string}
+   * @private
+   */
+  private transactionID: string
+  /**
+   * An array of strings representing a blacklist of filters
+   */
+  private filterBlacklist: string[]
+  /**
+   * The current log level for the application.
+   * @private
+   * @type {LOG_LEVELS}
+   */
+  private _LOG_LEVEL: LOG_LEVELS
+  /**
+   * The origin of the object.
+   * @private
+   * @type {any}
+   */
+  private origin: any
+
+  /**
+   * 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) {
+    abind(this)
+    //
+    this.origin = PURE_CONSOLE
+    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
+        : blacklist
+      : defaultSuppress
+    //
+    this.setupBindings()
+    //
+    this.log('Using logger with level: ' + this._LOG_LEVEL.toString())
+    this.debug('logger config: ', this.config)
+  }
+
+  /**
+   * 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
+  }
+
+  /**
+   * Logs the given arguments with the debug log level.
+   * @param {...any} args - The arguments to be logged.
+   * @returns None
+   */
+  public debug(...args) {
+    this.processLog(LOG_LEVELS.DEBUG, args)
+  }
+
+  /**
+   * Logs the given arguments with the INFO log level.
+   * @param {...any} args - The arguments to be logged.
+   * @returns None
+   */
+  public log(...args) {
+    this.processLog(LOG_LEVELS.INFO, args)
+  }
+
+  /**
+   * Logs an informational message.
+   * @param {...any} args - The message(s) to log.
+   * @returns None
+   */
+  public info(...args) {
+    this.processLog(LOG_LEVELS.INFO, args)
+  }
+
+  /**
+   * Logs a warning message with the provided arguments.
+   * @param {...any} args - The arguments to be logged as a warning message.
+   * @returns None
+   */
+  public warning(...args) {
+    this.processLog(LOG_LEVELS.WARN, args)
+  }
+
+  /**
+   * Logs a warning message to the console.
+   * @param {...any} args - The arguments to be logged.
+   * @returns None
+   */
+  public warn(...args) {
+    this.processLog(LOG_LEVELS.WARN, args)
+  }
+
+  /**
+   * Logs an error message with the given arguments.
+   * @param {...any} args - The arguments to log as an error message.
+   * @returns None
+   */
+  public error(...args) {
+    this.processLog(LOG_LEVELS.ERROR, 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
+   */
+  public exception(exception, ...args) {
+    this.iexception(exception, args)
+  }
+
+  /**
+   * Sets up the console bindings for logging purposes.
+   * @private
+   * @returns None
+   */
+  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),
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      warning: (...args) => this.processLog(LOG_LEVELS.WARN, args),
+      exception: (exception, ...args) => this.iexception(exception, args),
+    }
+  }
+
+  /**
+   * 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) {
+      return `${this.transactionID}` + ` [${level.toString()}] [${caller}] ${msg.join(' ')}`
+    } else {
+      return `[${level.toString()}] [${caller}] ${msg.join(' ')}`
+    }
+  }
+
+  /**
+   * Retrieves the name of the caller function at the specified index in the stack trace.
+   * @param {number} index - The index of the caller function in the stack trace.
+   * @returns {string} The name of the caller function along with the file path and line number.
+   */
+  private callerName(index: number): string {
+    const safeIndex = Math.min(index, stackTrace.get().length)
+    if (stackTrace.get()[safeIndex]) {
+      let callerName = stackTrace?.get()?.[safeIndex]?.getFileName()?.split('/')
+      callerName = callerName?.slice(callerName?.indexOf('src'))?.join('/')
+      return callerName + ':' + stackTrace?.get()?.[safeIndex]?.getLineNumber()
+    }
+    return ''
+  }
+
+  /**
+   * Processes log messages based on the specified log level.
+   * @param {LOG_LEVELS} level - The level of the log message.
+   * @param {any} args - The arguments to be logged.
+   * @returns None
+   */
+  private processLog(level: LOG_LEVELS, args: any): void {
+    if (level < this._LOG_LEVEL) return
+    //get args
+    const msg: string[] = []
+    for (const arg of args) {
+      // Deep clone object so we dont modify source
+      const fMsg = this.formatArgument(arg)
+      msg.push(fMsg)
+    }
+    //push into logs stack
+    // todo: improve error stack
+    this.pushLog(level, this.formattedLog(level, msg, this.callerName(3)))
+  }
+
+  private formatArgument(arg: any): string {
+    if (arg instanceof Error) {
+      return arg.message + '\n' + arg.stack
+    }
+
+    if (arg && typeof arg === 'object') {
+      return stringify(this.suppressSensitiveInfo(JSON.parse(stringify(arg))), null, 2)
+    }
+
+    return `${this.suppressSensitiveInfo(arg)}`
+  }
+
+  /**
+   * 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 iexception(exception: Error, ...args): void {
+    //format message
+    const msg: Array<string> = []
+    //push exeception
+    msg.push(exception.toString() + ' -')
+    //get args
+    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)))
+  }
+
+  /**
+   * 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 {
+    DEFAULT_LOG_FUNCTION.apply(PURE_CONSOLE, [fMsg])
+  }
+
+  /**
+   * 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 | any[] {
+    if (!value || !this.filterBlacklist.length) return value
+
+    const parent = [value]
+    const stack: SupressableItem[] = [{ value, parent, key: 0 }]
+
+    while (stack.length > 0) {
+      this.suppressSensitiveInfoItem(stack.pop()!, stack.push.bind(stack))
+    }
+
+    return parent[0]
+  }
+
+  private suppressSensitiveInfoItem(
+    { value, parent, key }: SupressableItem,
+    push: (e: SupressableItem) => void
+  ) {
+    if (!value) return
+
+    if (typeof value === 'string') {
+      this.suppressSensitiveString({ value, parent, key }, push)
+    } else if (Array.isArray(value)) {
+      value.forEach((v, index) => push({ value: v, parent: value, key: index }))
+    } else if (typeof value === 'object') {
+      this.suppressSensitiveObject(value, push)
+    }
+  }
+
+  private suppressSensitiveString(
+    { value, parent, key }: SupressableItem,
+    push: (e: SupressableItem) => void
+  ) {
+    let modifiedValue = value
+    try {
+      // Try to parse json string
+      modifiedValue = JSON.parse(value)
+      push({ value: modifiedValue, parent, key })
+    } catch {
+      const lower = value.toLowerCase()
+      if (this.filterBlacklist.some(f => lower == f))
+        modifiedValue = `**SUPPRESSED_SENSITIVE_DATA** (${String(modifiedValue)?.length || 0} len)`
+    }
+    parent[key] = modifiedValue
+  }
+
+  private suppressSensitiveObject(value: object, push: (e: SupressableItem) => void) {
+    Object.entries(value).forEach(([k, v]) => {
+      const lower = k.toLowerCase()
+      const match = v && this.filterBlacklist.some(f => lower == f)
+      if (match) {
+        value[k] = `**SUPPRESSED_SENSITIVE_DATA** (${String(v)?.length || 0} len)`
+      } else {
+        push({ value: v, parent: value, key: k })
+      }
+    })
+  }
+}

package/src/Mailer/Mailer.ts

@@ -0,0 +1,217 @@
+import * as SES from '@aws-sdk/client-ses'
+import { defaultProvider } from '@aws-sdk/credential-provider-node'
+import Email from 'email-templates'
+import nodemailer from 'nodemailer'
+import type SESTransport from 'nodemailer/lib/ses-transport'
+
+export default class Mailer {
+  /**
+   * The starting point of a range.
+   * @type {string}
+   */
+  private readonly from: string
+  /**
+   * The default file template for the application.
+   * @type {string}
+   */
+  private readonly templateDefaultFile: string = 'html'
+  /**
+   * 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>
+  >
+
+  /**
+   * 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
+    this.transporter = nodemailer.createTransport({
+      SES: {
+        ses: new SES.SESClient({
+          credentials: defaultProvider(),
+          apiVersion: '2010-12-01',
+          region,
+        }),
+        aws: SES,
+      },
+    })
+  }
+
+  /**
+   * 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>,
+    htmlMessage: string,
+    subject: string,
+    optionalCC?: string | Array<string>,
+    optionalFrom?: string,
+    optionalReplyTo?: string,
+    // TODO: improve attachment type -> Attachment
+    optionalAttachments?: any[],
+    optionalTransport?: Email.NodeMailerTransportOptions
+  ) {
+    //Generate emails
+    const email = new Email({
+      message: {
+        from: optionalFrom || this.from,
+        to: to,
+        html: htmlMessage,
+        subject,
+        ...(optionalAttachments ? { attachments: optionalAttachments } : {}),
+        ...(optionalCC ? { cc: optionalCC } : {}),
+        ...(optionalReplyTo ? { replyTo: optionalReplyTo } : {}),
+      },
+      transport: optionalTransport || this.transporter,
+      send: true,
+    })
+    //
+    let resp = null
+    try {
+      resp = await email.send()
+      console.debug('Mailer resp:', resp)
+    } catch (e) {
+      console.error('Mailer error:', e)
+      throw e
+    }
+    return resp
+  }
+
+  /**
+   * 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>,
+    templates: string | Array<string>,
+    data: object,
+    optionalCC?: string | Array<string>,
+    optionalFrom?: string,
+    optionalReplyTo?: string,
+    // TODO: improve attachment type -> Attachment
+    optionalAttachments?: any[],
+    optionalTransport?: Email.NodeMailerTransportOptions
+  ) {
+    //Generate emails
+    const email = new Email({
+      message: {
+        from: optionalFrom || this.from,
+        to: to,
+        ...(optionalAttachments ? { attachments: optionalAttachments } : {}),
+        ...(optionalCC ? { cc: optionalCC } : {}),
+        ...(optionalReplyTo ? { replyTo: optionalReplyTo } : {}),
+      },
+      transport: optionalTransport || this.transporter,
+      send: true,
+    })
+    //
+    let resp = null
+    try {
+      const chosenTemplate = await this.chooseTemplate(templates, data)
+      resp = await email.send({ template: chosenTemplate, locals: data })
+      console.debug('Mailer resp:', resp)
+    } catch (e) {
+      console.error('Mailer error:', e)
+      throw e
+    }
+    return resp
+  }
+
+  /**
+   * 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,
+    portNumber: number,
+    user: string,
+    password: string
+  ): Email.NodeMailerTransportOptions {
+    const smtpTransporter = nodemailer.createTransport({
+      host: host,
+      port: portNumber,
+      connectionTimeout: 2000,
+      auth: {
+        user: user,
+        pass: password,
+      },
+    })
+    return smtpTransporter
+  }
+
+  /**
+   * 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)) {
+      //For each template check if can render it
+      for (const template of templates) {
+        if (await this.canRenderTemplate(template, data)) return template
+      }
+    } else if (templates) {
+      if (await this.canRenderTemplate(templates, data)) return templates
+    }
+    throw new Error(
+      `Could not render email with template ${templates} and following data. Please, check logs above! ` +
+        JSON.stringify(data, null, 2)
+    )
+  }
+
+  /**
+   * 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> {
+    const validRenderResp = await Mailer.renderTemplate(
+      `${template}/${this.templateDefaultFile}`,
+      data
+    )
+    return validRenderResp != null
+  }
+
+  /**
+   * Renders the given template with the provided data using the Email class.
+   * @param {string} template - The name or path of the template to render.
+   * @param {object} data - The data object to pass to the template.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the template was rendered successfully, false otherwise.
+   */
+  public static async renderTemplate(template: string, data: object): Promise<any> {
+    let validRenderResp: string | null = null
+    try {
+      const email = new Email()
+      validRenderResp = await email.render(`${template}`, data)
+    } catch (e) {
+      console.log(`Error while checking renderability of email template ${template}`, e)
+    }
+    return validRenderResp
+  }
+}

package/src/Publisher/Publisher.ts

@@ -0,0 +1,96 @@
+import {
+  SNSClient,
+  PublishCommand,
+  PublishCommandOutput,
+  PublishCommandInput,
+} from '@aws-sdk/client-sns'
+import sha1 from 'sha1'
+//reusable client
+/**
+ * A variable that holds the connection to the SNS client for publishing messages.
+ * @type {SNSClient | null}
+ */
+// eslint-disable-next-line no-var
+let PUBLISHER_CONN: SNSClient | null = null
+/**
+ * The connection hash for the publisher. It is initially set to null.
+ * @type {string | null}
+ */
+// eslint-disable-next-line no-var
+let PUBLISHER_CONN_HASH: string | null = null
+
+/**
+ * Represents the configuration options for a publisher.
+ * @typedef {Object} PublisherConfig
+ * @property {string} [region] - The region where the publisher is located.
+ */
+export type PublisherConfig = {
+  region?: string
+}
+
+/**
+ * Represents a publisher that can publish messages to an SNS topic.
+ */
+export default class Publisher {
+  /**
+   * The region of the object or entity.
+   * @private
+   * @type {string}
+   */
+  private region: string
+
+  /**
+   * Constructs a new instance of the Publisher class.
+   * @param {PublisherConfig} [config] - The configuration object for the Publisher.
+   * @returns None
+   */
+  constructor(config?: PublisherConfig) {
+    if (config && config.region) {
+      this.region = config.region
+      // console.debug(`Using region: ${this.region}`);
+    }
+  }
+
+  /**
+   * Publishes a message on a specified topic.
+   * @param {any} messageObject - The message object to be published.
+   * @param {string} topic - The ARN of the topic to publish the message to.
+   * @param {object} [additionalProps] - Additional properties to include in the publish command.
+   * @returns {Promise<PublishCommandOutput>} - A promise that resolves to the response from the publish command.
+   */
+  public async publishOnTopic(
+    messageObject: any,
+    topic: string,
+    additionalProps?: object
+  ): Promise<PublishCommandOutput | undefined> {
+    let resp: undefined | PublishCommandOutput = undefined
+    try {
+      this.connect()
+      //Send to SNS
+      const params: PublishCommandInput = {
+        Message: JSON.stringify(messageObject),
+        TopicArn: topic,
+        ...(additionalProps ? additionalProps : {}),
+      }
+      resp = await PUBLISHER_CONN!.send(new PublishCommand(params))
+    } catch (e) {
+      console.error(`Error while publishing into topic ${topic} with error: ${e}`)
+    }
+    console.debug('Publisher resp', resp)
+    return resp
+  }
+
+  /**
+   * Establishes a connection to the SNS client if it does not already exist or if the region has changed.
+   * @returns None
+   */
+  private connect(): void {
+    if ((!PUBLISHER_CONN && !PUBLISHER_CONN_HASH) || PUBLISHER_CONN_HASH != sha1(this.region)) {
+      PUBLISHER_CONN = new SNSClient({
+        apiVersion: '2010-03-31',
+        region: this.region,
+      })
+      PUBLISHER_CONN_HASH = sha1(this.region).toString()
+    }
+  }
+}