miolo 3.0.0-beta.21 → 3.0.0-beta.210

package/src/engines/geoip/index.mjs

@@ -1,66 +1,61 @@
-import fs from 'fs'
-import {Reader} from '@maxmind/geoip2-node'
+import fs from "node:fs"
+import { Reader } from "@maxmind/geoip2-node"
 
-let _geoip_reader = undefined
+let _geoip_reader
 
-const _geoip_def_local_ips= [
-  '127.0.0.1',
-  '::1:',
-  '172.19.0.1' // Docker inner - probably healthcheck
+const _geoip_def_local_ips = [
+  "127.0.0.1",
+  "::1:",
+  "172.19.0.1" // Docker inner - probably healthcheck
 ]
 
 function _geoip_is_local(ip, local_ips = []) {
   // if (process.env.NODE_ENV == 'development') {
   //   return true
   // }
-  
-  const all_local_ips = [
-      ..._geoip_def_local_ips,
-      ...local_ips || []
-    ]
+
+  const all_local_ips = [..._geoip_def_local_ips, ...(local_ips || [])]
   return all_local_ips.indexOf(ip) >= 0
 }
 
-
-
-function _geoip_init(db = '/var/lib/GeoIP/GeoLite2-City.mmdb', logger= console) {
+function _geoip_init(db = "/var/lib/GeoIP/GeoLite2-City.mmdb", logger = console) {
   try {
-    if (_geoip_reader != undefined) {
+    if (_geoip_reader !== undefined) {
       return _geoip_reader
     }
     const dbBuffer = fs.readFileSync(db)
     _geoip_reader = Reader.openBuffer(dbBuffer)
     return _geoip_reader
-  } catch(error) {
+  } catch (error) {
     logger.error(`[geoip] Error initing:`)
     logger.error(error)
     return undefined
   }
 }
 
-export const geoip_localize_ip= (ip, config, logger= console) => {
+export const geoip_localize_ip = (ip, config, logger = console) => {
   if (_geoip_is_local(ip, config?.local_ips)) {
     return {
       local: true,
-      country: '',
-      city: '',
-    }      
+      country: "",
+      city: ""
+    }
   }
 
   try {
     const reader = _geoip_init(config?.db, logger)
-    const resp= reader.city(ip)
+    const resp = reader.city(ip)
     return {
       country: resp.country.isoCode,
-      city   : resp.city?.names?.en
+      city: resp.city?.names?.en
     }
-  } catch(error) {
+  } catch (_) {
     logger.error(`[geoip] Error localizing IP ${ip} (not in the database)`)
-    //logger.error(error)
+    //logger.error(_)
   }
 
   return {
-    country: '',
-    city: '',
-  }  
+    country: "",
+    city: ""
+  }
 }

package/src/engines/http/index.mjs

@@ -1,7 +1,7 @@
-import http                         from 'http'
+import http from "node:http"
+import https from "node:https"
 //import util                       from 'util'
-import { createHttpTerminator }     from 'http-terminator'
-
+import { createHttpTerminator } from "http-terminator"
 
 // promisify the server.listen()
 
@@ -25,30 +25,41 @@ const _listenAsync = (server, port, hostname) => {
 
 export function init_http_server(app, config) {
   const miolo = app.context.miolo
-  const logger= miolo.logger
+  const logger = miolo.logger
 
   const _http_start = async () => {
     try {
       // If previous server already created, lets avoid
-      if (app.http?.server != undefined) {
-        logger.warn(`[http][start] Server already running on ${app?.http?.hostname}:${app?.http?.port}`)
+      if (app.http?.server !== undefined) {
+        logger.warn(
+          `[http][start] Server already running on ${app?.http?.hostname}:${app?.http?.port}`
+        )
         return
       }
 
       // Init server
-      const server = http.createServer(app.callback())
+      const server =
+        config?.ssl === undefined
+          ? http.createServer(app.callback())
+          : https
+              .createServer(config.ssl, app.callback())
+              .listen(config.port, config.hostname, () => {
+                logger.info("[http][start] Server running at https://localhost:8010")
+              })
 
       // Init terminator
       const httpTerminator = createHttpTerminator({
-        server,
+        server
       })
 
       const http_stop = async () => {
         try {
           await httpTerminator.terminate()
           delete app.http.server
-          logger.info(`[http][stop] miolo has been shutdowned from ${config.hostname}:${config.port}`)
-        } catch(error) {
+          logger.info(
+            `[http][stop] miolo has been shutdowned from ${config.hostname}:${config.port}`
+          )
+        } catch (error) {
           logger.error(`[http][stop] error: ${error}`)
         }
       }
@@ -59,21 +70,21 @@ export function init_http_server(app, config) {
       // Finally start the server
       await _listenAsync(server, config.port, config.hostname)
       logger.info(`[http][start] miolo is listening on ${config.hostname}:${config.port}`)
-    } catch(error) {
+    } catch (error) {
       logger.error(`[http][start] error: ${error}`)
     }
-  }  
+  }
 
   // Attach objects to app
   app.http = {
     server: undefined,
     start: _http_start,
     stop: async () => {
-      logger.warn(`[http] stop() stop() function still not attached. Is server running?`)
+      logger.warn(`[http] stop() function still not attached. Is server running?`)
     },
     hostname: config.hostname,
     port: config.port
-  }  
+  }
 
   return app
-}
+}

package/src/engines/logger/buildErrorEmailBody.mjs

@@ -0,0 +1,72 @@
+import os from "node:os"
+
+/**
+ * Genera un cuerpo de email HTML a partir del objeto info de Winston.
+ * @param {Object} info - El objeto info transformado por Winston.
+ * @returns {String} HTML string.
+ */
+export default function buildErrorEmailBody(info) {
+  // 1. Extraemos propiedades estándar y conocidas
+  const { timestamp, level, message, stack, ...metadata } = info
+
+  // 2. Preparamos el Stack Trace (si existe)
+  // Nota: Winston solo tiene 'stack' si usas format.errors({ stack: true })
+  const stackHtml = stack
+    ? `<div style="margin-top: 20px;">
+         <h3 style="color: #d9534f;">Stack Trace</h3>
+         <pre style="background: #f4f4f4; padding: 10px; border: 1px solid #ddd; overflow-x: auto; font-size: 12px; font-family: monospace;">${stack}</pre>
+       </div>`
+    : "<p><em>No stack trace available (Log was likely a string or logical error).</em></p>"
+
+  // 3. Preparamos los Metadatos (el resto de propiedades en info)
+  // Esto es vital en Koa para ver requestId, url, method, etc.
+  const metaRows = Object.entries(metadata)
+    .map(([key, value]) => {
+      // Si el valor es un objeto complejo, lo pasamos a string
+      const displayValue =
+        typeof value === "object"
+          ? `<pre style="margin: 0;">${JSON.stringify(value, null, 2)}</pre>`
+          : value
+
+      return `
+      <tr>
+        <td style="padding: 8px; border-bottom: 1px solid #ddd; font-weight: bold; width: 30%;">${key}</td>
+        <td style="padding: 8px; border-bottom: 1px solid #ddd;">${displayValue}</td>
+      </tr>
+    `
+    })
+    .join("")
+
+  const metadataHtml =
+    metaRows.length > 0
+      ? `<div style="margin-top: 20px;">
+         <h3>Metadata / Context</h3>
+         <table style="width: 100%; border-collapse: collapse; font-family: sans-serif; font-size: 14px;">
+           ${metaRows}
+         </table>
+       </div>`
+      : ""
+
+  // 4. Construcción final del HTML
+  return `
+    <div style="font-family: Arial, sans-serif; color: #333; line-height: 1.6;">
+      <h2 style="background-color: #ca7d7bff; color: white; padding: 10px;">🚨 Error at [${process.env.MIOLO_NAME || "miolo"}]</h2>
+      
+      <div style="padding: 10px; border: 1px solid #ddd; background-color: #fff9f9;">
+        <strong>Message:</strong> <span style="font-size: 1.2em;">${message
+          .split("\n")
+          .map((l) => `<div>${l}</div>`)
+          .join("\n")}</span><br>
+        <strong>Time:</strong> ${timestamp || new Date().toISOString()}<br>
+        <strong>Server:</strong> ${os.hostname()}
+      </div>
+
+      ${stackHtml}
+      ${metadataHtml}
+      
+      <div style="margin-top: 30px; font-size: 12px; color: #777; border-top: 1px solid #eee; padding-top: 10px;">
+        Sent automatically by <strong>miolo</strong> logger.
+      </div>
+    </div>
+  `
+}

package/src/engines/logger/index.mjs

@@ -1,67 +1,66 @@
 // import fs from 'fs'
 // import path from 'path'
-import { red, cyan, magenta, yellow, gray, red_light } from 'tinguir'
+import { blue, blue_light, cyan, magenta, red, yellow } from "tinguir"
+import { createLogger, format, transports } from "winston"
+import injectStackTrace from "./injectStackTrace.mjs"
 /* https://github.com/winstonjs/winston/issues/925 */
 /* https://github.com/winstonjs/winston/issues/287 */
-import {init_logger_to_mail} from './logger_mail.mjs'
-import { createLogger, format, transports } from 'winston'
-import { reopenTransportOnHupSignal } from './reopenTransportOnHupSignal.mjs'
+import { init_logger_to_mail } from "./logger_mail.mjs"
+import { reopenTransportOnHupSignal } from "./reopenTransportOnHupSignal.mjs"
+
 // import  'winston-daily-rotate-file'
 // import { /*intre_to_str,*/ intre_now } from 'intre'
 
 const { combine, timestamp, _label, printf, errors } = format
 
-
-
-const init_logger = (config, emailer, prefix= 'miolo') => {
-  const LEVEL_COLORS= {
-    silly  : gray,
-    debug  : magenta,
+const init_logger = (config, emailer, prefix = "miolo") => {
+  const LEVEL_COLORS = {
+    silly: blue_light,
+    debug: blue,
     verbose: cyan,
-    info   : yellow,
-    warn   : red_light,
-    error  : red
+    info: magenta,
+    warn: yellow,
+    error: red
   }
 
-  const LEVEL_ABBRV= {
-    silly  : 'sly',
-    debug  : 'dbg',
-    verbose: 'vbs',
-    info   : 'inf',
-    warn   : 'wrn',
-    error  : 'err',
+  const LEVEL_ABBRV = {
+    silly: "sly",
+    debug: "dbg",
+    verbose: "vbs",
+    info: "inf",
+    warn: "wrn",
+    error: "err"
   }
 
   const _INDENT_SIZE = 4
   let _INDENT = 0
-  let _SECTIONS = {}
+  const _SECTIONS = {}
 
-  const myFormat = info => {
+  const myFormat = (info) => {
     const lc = LEVEL_COLORS[info.level]
     const tm = new Date(info.timestamp)
-    const ts= tm.toLocaleString(config?.format?.locale || 'en')
-    let sindent = ''.padStart(_INDENT, ' ')
+    const ts = tm.toLocaleString(config?.format?.locale || "en")
+    const sindent = "".padStart(_INDENT, " ")
     //const ts= tm.toString().substr(4, 20)
-    const log= `[${prefix}] ${lc(ts)} ${lc(LEVEL_ABBRV[info.level])} ${sindent}${info.message}`
-    return info.stack
-      ? `${log}\n${info.stack}`
-      : log    
+    const log = `[${prefix}] ${lc(ts)} ${lc(LEVEL_ABBRV[info.level])} ${sindent}${info.message}`
+    return info.stack ? `${log}\n${info.stack}` : log
   }
 
-  let _log_transports= []
+  const _log_transports = []
   //
   // Console transport
   // If we're not in production then log to the `console` with the format:
   // `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
-  // 
+  //
 
   if (config?.console?.enabled === true) {
     _log_transports.push(
-        new transports.Console({
-          humanReadableUnhandledException: true,
-          level    : config?.console?.level || config?.level || 'silly',
-          handleExceptions: true
-    }))
+      new transports.Console({
+        humanReadableUnhandledException: true,
+        level: config?.console?.level || config?.level || "silly",
+        handleExceptions: true
+      })
+    )
   }
 
   //
@@ -72,62 +71,60 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
   //  https://gist.github.com/suprememoocow/5133080
   //
   if (config?.file?.enabled === true) {
-    
-    const fileTransport = new transports.File({ 
-      filename : config?.file?.filename 
-      ? config.file.filename.replace('%MIOLO%', prefix)
-      : '/var/log/afialapis/miolo.log',
-      level    : config?.file?.level || config?.level || 'info' ,
+    const fileTransport = new transports.File({
+      filename: config?.file?.filename
+        ? config.file.filename.replace("%MIOLO%", prefix)
+        : "/var/log/afialapis/miolo.log",
+      level: config?.file?.level || config?.level || "info",
       humanReadableUnhandledException: true,
       handleExceptions: true,
       maxRetries: 10
     })
-    
+
     if (config?.file?.hup_patch === true) {
       reopenTransportOnHupSignal(fileTransport)
     }
 
     _log_transports.push(fileTransport)
 
-
-  //    const _file_log = (s) => {
-  //      const filename = path.join(fileTransport.dirname, fileTransport.filename)
-  //      
-  //      // console.log(fileTransport._stream )
-  //      const msg = myFormat({
-  //        level: 'info',
-  //        message: `[logger][file-rotate] ${s}\n`,
-  //        timestamp: intre_now()
-  //      })
-  //
-  //      try {
-  //        fs.accessSync(filename, fs.constants.F_OK)
-  //        fs.appendFileSync(filename, msg)
-  //      } catch(_) {
-  //        fs.writeFileSync(filename, msg, { encoding: 'utf-8' })
-  //      }
-  //      if (config?.console?.enabled === true) {
-  //        if (fileTransport.levels[config?.console?.level || config?.level || 'error'] >= fileTransport.levels['info']) {
-  //          console.log(msg)
-  //        }
-  //      }
-  //    }
-  //
-  //    fileTransport.on('finish', function(info) {
-  //      // do something fun
-  //      _file_log('Log done')
-  //    })    
-  //    fileTransport.on('error', function(error) {
-  //      // do something fun
-  //      _file_log(red(`Error: ${error}`))
-  //    })
-  //
+    //    const _file_log = (s) => {
+    //      const filename = path.join(fileTransport.dirname, fileTransport.filename)
+    //
+    //      // console.log(fileTransport._stream )
+    //      const msg = myFormat({
+    //        level: 'info',
+    //        message: `[logger][file-rotate] ${s}\n`,
+    //        timestamp: intre_now()
+    //      })
+    //
+    //      try {
+    //        fs.accessSync(filename, fs.constants.F_OK)
+    //        fs.appendFileSync(filename, msg)
+    //      } catch(_) {
+    //        fs.writeFileSync(filename, msg, { encoding: 'utf-8' })
+    //      }
+    //      if (config?.console?.enabled === true) {
+    //        if (fileTransport.levels[config?.console?.level || config?.level || 'error'] >= fileTransport.levels['info']) {
+    //          console.log(msg)
+    //        }
+    //      }
+    //    }
+    //
+    //    fileTransport.on('finish', function(info) {
+    //      // do something fun
+    //      _file_log('Log done')
+    //    })
+    //    fileTransport.on('error', function(error) {
+    //      // do something fun
+    //      _file_log(red(`Error: ${error}`))
+    //    })
+    //
   }
 
   //  if (config?.file?.enabled === true) {
   //    const datePattern = config?.file?.datePattern || 'YYYY-MM-DD'
   //
-  //    const fileTransport = new transports.DailyRotateFile({ 
+  //    const fileTransport = new transports.DailyRotateFile({
   //      level    : config?.file?.level || config?.level || 'info' ,
   //
   //      frequency: config?.file?.frequency,
@@ -135,21 +132,21 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
   //      zippedArchive: config?.file?.zippedArchive == true,
   //      maxSize: config?.file?.maxSize || '20m',
   //      maxFiles: config?.file?.maxFiles || '10d',
-  //      
-  //      filename : config?.file?.filename 
+  //
+  //      filename : config?.file?.filename
   //        ? config.file.filename.replace('%MIOLO%', prefix)
-  //        : '/var/log/afialapis/miolo.%DATE%.log', 
-  //      
+  //        : '/var/log/afialapis/miolo.%DATE%.log',
+  //
   //      auditFile: config?.file?.auditFile
   //        ? config.file.auditFile.replace('%MIOLO%', prefix)
   //        : '/var/log/afialapis/miolo.audit.json',
-  //      
+  //
   //      symlinkName: config?.file?.symlinkName
   //        ? config.file.symlinkName.replace('%MIOLO%', prefix)
   //        : 'miolo.log',
   //
   //      createSymlink: config?.file?.createSymlink == true,
-  //      
+  //
   //      watchLog: true,
   //
   //      humanReadableUnhandledException: true,
@@ -159,7 +156,7 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
   //    const _file_log = (s) => {
   //      const currentDate = intre_to_str(intre_now(), datePattern)
   //      const filename = path.join(fileTransport.dirname, fileTransport.filename.replace('%DATE%', currentDate))
-  //      
+  //
   //      const msg = myFormat({
   //        level: 'info',
   //        message: `[logger][file-rotate] ${s}\n`,
@@ -205,19 +202,18 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
   //    _log_transports.push(fileTransport)
   //  }
 
-
   //  if (config?.file?.enabled === true) {
-  //    const fileTransport = new transports.File({ 
+  //    const fileTransport = new transports.File({
   //      level    : config?.file?.level || config?.level || 'info' ,
   //
   //      zippedArchive: config?.file?.zippedArchive == true,
   //      maxsize: config?.file?.maxsize || (1024 * 1024 * 20),
   //      maxFiles: config?.file?.maxFiles || 20,
-  //        //      
-  //      filename : config?.file?.filename 
+  //        //
+  //      filename : config?.file?.filename
   //        ? config.file.filename.replace('%MIOLO%', prefix)
-  //        : '/var/log/afialapis/miolo.log', 
-  //        //      
+  //        : '/var/log/afialapis/miolo.log',
+  //        //
   //
   //      humanReadableUnhandledException: true,
   //      handleExceptions: true,
@@ -225,22 +221,21 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
   //      tailable: true,
   //
   //    })
-  //  
+  //
   //    _log_transports.push(fileTransport)
   //  }
 
-
   //
   // Mail transport
   //
-  if (config?.mail?.enabled === true) {    
-    const MailerLogger= init_logger_to_mail(config.mail, emailer)
+  if (emailer && config?.mail?.enabled === true) {
+    const MailerLogger = init_logger_to_mail(config.mail, emailer)
     transports.MailerLogger = MailerLogger
 
     _log_transports.push(
       new transports.MailerLogger({
         humanReadableUnhandledException: true,
-        handleExceptions: true    
+        handleExceptions: true
       })
     )
   }
@@ -249,12 +244,8 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
   // Logger
   //
   const logger = createLogger({
-    level: config?.level || 'silly',
-    format: combine(
-      errors({ stack: true }),
-      timestamp(),
-      printf(myFormat)
-    ),
+    level: config?.level || "silly",
+    format: combine(errors({ stack: true }), injectStackTrace(), timestamp(), printf(myFormat)),
     transports: _log_transports
   })
 
@@ -262,52 +253,53 @@ const init_logger = (config, emailer, prefix= 'miolo') => {
     const _indented_func = (text, opts) => {
       try {
         if (opts?.section) {
-          if (! (opts.section in _SECTIONS)) {
+          if (!(opts.section in _SECTIONS)) {
             // Section starts
-            _SECTIONS[opts.section]= {
-              indentIncr: parseInt(opts?.indent || _INDENT_SIZE),
+            _SECTIONS[opts.section] = {
+              indentIncr: parseInt(opts?.indent || _INDENT_SIZE, 10),
               timeStart: Date.now()
             }
             const nIndent = Math.max(_INDENT + _SECTIONS[opts.section].indentIncr, 0)
             f(text, opts)
-            _INDENT= nIndent
-            
+            _INDENT = nIndent
           } else {
             // Section ends
-            const elapsed = parseFloat( (Date.now() - _SECTIONS[opts.section].timeStart) / 1000.0 ).toFixed(2)
+            const elapsed = parseFloat(
+              (Date.now() - _SECTIONS[opts.section].timeStart) / 1000.0
+            ).toFixed(2)
             text = `${text} (time: ${elapsed})`
-            _INDENT-= _SECTIONS[opts.section].indentIncr
+            _INDENT -= _SECTIONS[opts.section].indentIncr
             f(text, opts)
-            delete _SECTIONS[opts.section]      
+            delete _SECTIONS[opts.section]
           }
         } else {
           f(text, opts)
         }
-      } catch(error) {
+      } catch (error) {
         // TODO - How to exxpose info from here
         console.error(error)
-
       }
     }
-    Object.defineProperty(_indented_func, "name", { value: name });
+    Object.defineProperty(_indented_func, "name", { value: name })
     return _indented_func
   }
 
-  logger.error   = _make_indented_log(logger.error, 'error')
-  logger.warn    = _make_indented_log(logger.warn, 'warn')
-  logger.info    = _make_indented_log(logger.info, 'info')
-  logger.http    = _make_indented_log(logger.http, 'http')
-  logger.verbose = _make_indented_log(logger.verbose, 'verbose')
-  logger.debug   = _make_indented_log(logger.debug, 'debug')
-  logger.silly   = _make_indented_log(logger.silly, 'silly')
+  logger.error = _make_indented_log(logger.error, "error")
+  logger.warn = _make_indented_log(logger.warn, "warn")
+  logger.info = _make_indented_log(logger.info, "info")
+  logger.http = _make_indented_log(logger.http, "http")
+  logger.verbose = _make_indented_log(logger.verbose, "verbose")
+  logger.debug = _make_indented_log(logger.debug, "debug")
+  logger.silly = _make_indented_log(logger.silly, "silly")
 
   //console.log(logger.transports[0])
   try {
-    logger.debug(`[logger] Inited for ${logger.transports.map(t => `${t.name} (${t.level})${t.silent ? red(' SILENT!') : ''}`).join(',')}`)
-  } catch(_) {}
+    logger.debug(
+      `[logger] Inited for ${logger.transports.map((t) => `${t.name} (${t.level})${t.silent ? red(" SILENT!") : ""}`).join(",")}`
+    )
+  } catch (_) {}
 
   return logger
 }
 
-
-export {init_logger}
+export { init_logger }