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

package/src/engines/logger/injectStackTrace.mjs

@@ -0,0 +1,59 @@
+import { format } from "winston"
+
+const injectStackTrace = format((info) => {
+  // Solo nos interesa inyectar stack si es nivel error y NO tiene stack
+  if (info.level === "error" && !info.stack) {
+    const syntheticError = new Error(info.message)
+    const stackLines = syntheticError.stack.split("\n")
+
+    // 1. Definimos nuestro "Ancla".
+    // Es el archivo que actúa de frontera entre tu framework y el código de negocio.
+    // Usamos una cadena parcial única para identificarlo.
+    // DEV:  'src/engines/logger/index.mjs'
+    // PROD: ''
+
+    // 2. Buscamos en qué línea del stack aparece tu wrapper
+    let wrapperIndex = stackLines.findIndex((line) => line.includes("src/engines/logger/index.mjs"))
+    if (wrapperIndex === -1) {
+      for (const [lidx, l] of stackLines.entries()) {
+        if (
+          l.includes(
+            `${process.env.MIOLO_NAME || "miolo"}.${process.env.MIOLO_BUILD_SERVER_EXT || "node.bundle.mjs"}`
+          )
+        ) {
+          const segs = ["Format.transform", "DerivedLogger"]
+          segs.forEach((seg) => {
+            if (l.includes(seg)) {
+              wrapperIndex = lidx
+            }
+          })
+        }
+      }
+    }
+
+    let cleanStackLines = stackLines
+
+    if (wrapperIndex !== -1) {
+      // CASO ÉXITO: Encontramos tu wrapper.
+      // El stack útil empieza justo en la línea SIGUIENTE (+1).
+      // Mantenemos la cabecera (línea 0) y pegamos del wrapper hacia abajo.
+      cleanStackLines = [stackLines[0], ...stackLines.slice(wrapperIndex + 1)]
+    }
+    // FALLBACK: Si por alguna razón extraña no pasa por tu wrapper,
+    // hacemos una limpieza conservadora básica (winston y node internals).
+    cleanStackLines = cleanStackLines.filter(
+      (line) =>
+        !line.includes("node_modules/winston") &&
+        !line.includes("node_modules/logform") &&
+        !line.includes("node_modules/koa-compose") &&
+        !line.includes("node:internal") &&
+        !line.includes("node_modules/readable-stream") &&
+        !line.includes("injectStackTrace.mjs")
+    )
+
+    info.stack = cleanStackLines.join("\n")
+  }
+  return info
+})
+
+export default injectStackTrace

package/src/engines/logger/logger_mail.mjs

@@ -1,89 +1,75 @@
 // "use strict";
-import util from 'util'
-import winston from 'winston'
-import { uncolor } from 'tinguir'
-
-function init_logger_to_mail(config, emailer) {
-
-
-  let MailerLogger = function (options) {
-      winston.Transport.call(this, options);
-      options = options || {};
-
-      this.level = config.level  || 'info'
-      this.ename = config?.name  || emailer.defaults.name
-      this.to    = config.to     || emailer.defaults.to
-      this.from  = config.from   || emailer.defaults.from
-      this.humanReadableUnhandledException = options.humanReadableUnhandledException || true;
-      this.handleExceptions                = options.handleExceptions || true;
-      this.json                            = options.json || false;
-      this.colorize                        = options.colorize || false;
 
+import util from "node:util"
+import { uncolor } from "tinguir"
+import winston from "winston"
+import buildErrorEmailBody from "./buildErrorEmailBody.mjs"
 
-
-      
-  };
+function init_logger_to_mail(config, emailer) {
+  const MailerLogger = function (options) {
+    winston.Transport.call(this, options)
+    options = options || {}
+
+    this.level = config.level || "info"
+    this.ename = config?.name || emailer.defaults.name
+    this.to = config.to || emailer.defaults.to
+    this.from = config.from || emailer.defaults.from
+    this.humanReadableUnhandledException = options.humanReadableUnhandledException || true
+    this.handleExceptions = options.handleExceptions || true
+    this.json = options.json || false
+    this.colorize = options.colorize || false
+  }
 
   /** @extends winston.Transport */
-  util.inherits(MailerLogger, winston.Transport);
+  util.inherits(MailerLogger, winston.Transport)
 
   //
   // Expose the name of this Transport on the prototype
   //
-  MailerLogger.prototype.name = 'MailerLogger';
-
+  MailerLogger.prototype.name = "MailerLogger"
 
   MailerLogger.prototype.log = function (info, callback) {
-    let self = this;
-
-    let title = ''
-    let body = ''
-
+    let title = ""
     try {
       try {
-        title= info.message.split("\n")[0]
-      } catch(e) {
-        title= info.message.toString();
+        title = info.message.split("\n")[0]
+      } catch (_) {
+        title = info.message.toString()
       }
-
-      title= uncolor(title)
-      
-    } catch(err) {
+      title = uncolor(title)
+    } catch (err) {
       title = `Could not create a title for the error (${err.toString()})`
     }
 
+    let body = info?.message || ""
     try {
-      try {
-        body = uncolor(info.message)
-      } catch(err) {
-        body = info.message.toString()
-      }  
-    } catch(err) {
-      body = `Could not create a body for the error (${err.toString()})`
-    }
-    
-    try {
-      let subject = `${config?.name} [${info.level.toUpperCase()}] ${title}`
+      body = uncolor(body)
+    } catch (_) {}
+
+    const html = buildErrorEmailBody(info)
 
-      let mail= {
-        from    : this.from,
-        to      : this.to,
-        subject : subject, 
-        text    : body
+    try {
+      const subject = `${config?.name} [${info.level.toUpperCase()}] ${title}`
+
+      const mail = {
+        from: this.from,
+        to: this.to,
+        subject: subject,
+        text: body,
+        html: html
       }
 
       emailer.queue_email(mail)
-      self.emit("logged")
+      this.emit("logged")
       callback(null, true)
-
-    } catch(error) {
+    } catch (_) {
       // TODO - How to exxpose info from here
-      self.emit("logged");
-      callback(null, true);    
+      this.emit("logged")
+      callback(null, true)
     }
-  };
-  
+  }
+
   return MailerLogger
 }
 
-export {init_logger_to_mail}
+export { init_logger_to_mail }

package/src/engines/logger/reopenTransportOnHupSignal.mjs

@@ -1,18 +1,18 @@
 /**
  * https://gist.github.com/suprememoocow/5133080
- * 
+ *
  * https://github.com/winstonjs/winston/issues/943
- * 
+ *
  * A function for reopening a winston File logging transport post logrotation on a HUP signal.
- * To send a HUP to your node service, use the postrotate configuration option from logrotate. 
+ * To send a HUP to your node service, use the postrotate configuration option from logrotate.
  *   `postrotate kill -HUP ‘cat /var/run/mynodeservice.pid‘`
  */
-import path from 'path'
-import fs from 'fs'
 
-export function reopenTransportOnHupSignal(fileTransport) {
-  process.on('SIGHUP', function() {    
+import fs from "node:fs"
+import path from "node:path"
 
+export function reopenTransportOnHupSignal(fileTransport) {
+  process.on("SIGHUP", () => {
     const fullname = path.join(fileTransport.dirname, fileTransport._getFile(false))
 
     //console.log(`[miolo][file-logger] SIGHUP received. Check if we need to re-open log file ${fullname}...`)
@@ -25,21 +25,21 @@ export function reopenTransportOnHupSignal(fileTransport) {
           fileTransport._stream.destroy() // Soon()
         }
 
-        let stream = fs.createWriteStream(fullname, fileTransport.options)
+        const stream = fs.createWriteStream(fullname, fileTransport.options)
         stream.setMaxListeners(Infinity)
 
         fileTransport._size = 0
         fileTransport._stream = stream
 
         //fileTransport.once('flush', function () {
-          fileTransport.opening = false
-          fileTransport.emit('open', fullname)
+        fileTransport.opening = false
+        fileTransport.emit("open", fullname)
         //})
 
         //fileTransport.flush()
 
         console.log(`[miolo][file-logger] Reopened ${fullname} successfully`)
-      } catch(error) {
+      } catch (error) {
         console.error(`[miolo][file-logger] Error reopening ${fullname}: ${error.toString()}`)
       }
     }
@@ -52,6 +52,5 @@ export function reopenTransportOnHupSignal(fileTransport) {
     })
     */
     return reopen()
-
   })
-}
+}

package/src/engines/parser/Parser.mjs

@@ -1,126 +1,143 @@
 export default class Parser {
-  
-  parse_value_str(v, required= false, def= undefined) {
-    if ((v==null) || (v==undefined)) {
+  parse_value_str(v, required = false, def = undefined) {
+    if (v === null || v === undefined) {
       if (required) {
-       throw `Wrong str value passed: ${v}`
+        throw `Wrong str value passed: ${v}`
       }
       return def
     }
-  
+
     return v.toString()
   }
-  
-  parse_field_str(fields, name, required= false, def= undefined) {
-    if ( ! (name in fields)) {
+
+  parse_field_str(fields, name, required = false, def = undefined) {
+    if (!(name in fields)) {
       if (required) {
-       throw `Expected str value not passed for ${name}`
+        throw `Expected str value not passed for ${name}`
       }
       return def
     }
-    return this.parse_value_str(fields[name], required, def)
+    try {
+      return this.parse_value_str(fields[name], required, def)
+    } catch (e) {
+      throw `parse_field_str() Error for ${name}: ${e}`
+    }
   }
-  
-  parse_value_int(v, required= false, def= undefined) {
-    let vi= parseInt(v)
-    if ((vi==null) || (isNaN(vi))) {
+
+  parse_value_int(v, required = false, def = undefined) {
+    const vi = parseInt(v, 10)
+    if (vi === null || Number.isNaN(Number(vi))) {
       if (required) {
-       throw `Wrong int value passed: ${v}`
+        throw `Wrong int value passed: ${v}`
       }
       return def
     }
-  
+
     return vi
   }
-  
-  parse_field_int(fields, name, required= false, def= undefined) {
-    if ( ! (name in fields)) {
+
+  parse_field_int(fields, name, required = false, def = undefined) {
+    if (!(name in fields)) {
       if (required) {
-       throw `Expected int value not passed for ${name}`
+        throw `Expected int value not passed for ${name}`
       }
       return def
     }
-    return this.parse_value_int(fields[name], required, def)
+    try {
+      return this.parse_value_int(fields[name], required, def)
+    } catch (e) {
+      throw `parse_field_int() Error for ${name}: ${e}`
+    }
   }
-  
-  parse_value_float(v, required= false, def= undefined) {
-    const vf= parseFloat(v)
-    if ((vf==null) || (isNaN(vf))) {
+
+  parse_value_float(v, required = false, def = undefined) {
+    const vf = parseFloat(v)
+    if (vf === null || Number.isNaN(Number(vf))) {
       if (required) {
-       throw `Wrong float value passed: ${v}`
+        throw `Wrong float value passed: ${v}`
       }
       return def
     }
-  
+
     return v
   }
-  
-  parse_field_float(fields, name, required= false, def= undefined) {
-    if ( ! (name in fields)) {
+
+  parse_field_float(fields, name, required = false, def = undefined) {
+    if (!(name in fields)) {
       if (required) {
-       throw `Expected float value not passed for ${name}`
+        throw `Expected float value not passed for ${name}`
       }
       return def
     }
-  
-    return this.parse_value_float(fields[name], required, def) 
+    try {
+      return this.parse_value_float(fields[name], required, def)
+    } catch (e) {
+      throw `parse_field_float() Error for ${name}: ${e}`
+    }
   }
-  
-  parse_value_bool(v, required= false, def= undefined) {
-    if ((v==null) || (v==undefined)) {
+
+  parse_value_bool(v, required = false, def = undefined) {
+    if (v === null || v === undefined) {
       if (required) {
-       throw `Wrong bool value passed for ${name}`
+        throw `Wrong bool value passed for ${name}`
       }
       return undefined
     }
-    if ( (v===true) || (v==='true') ||(v==='True') ||(v===1) ||(v==='1')) {
+    if (v === true || v === "true" || v === "True" || v === 1 || v === "1") {
       return true
     }
-    if ( (v===false) || (v==='false') ||(v==='False') ||(v===0) ||(v==='0')) {
+    if (v === false || v === "false" || v === "False" || v === 0 || v === "0") {
       return false
     }
-  
+
     return def
   }
-  
-  parse_field_bool(fields, name, required= false, def= undefined) {
-    if ( ! (name in fields)) {
+
+  parse_field_bool(fields, name, required = false, def = undefined) {
+    if (!(name in fields)) {
       if (required) {
-       throw `Expected bool value not passed for ${name}`
+        throw `Expected bool value not passed for ${name}`
       }
       return def
     }
-  
-    return this.parse_value_bool(fields[name], required, def) 
+    try {
+      return this.parse_value_bool(fields[name], required, def)
+    } catch (e) {
+      throw `parse_field_bool() Error for ${name}: ${e}`
+    }
   }
-  
-  parse_value_obj(v, required= false, def= undefined) {
-    if ((v==null) || (v==undefined)) {
+
+  parse_value_obj(v, required = false, def = undefined) {
+    if (v === null || v === undefined) {
       if (required) {
-       throw `Wrong obj value passed: ${v}`
+        throw `Wrong obj value passed: ${v}`
       }
       return def
     }
-    if (Object.keys(v).length==0) {
+    if (Object.keys(v).length === 0) {
       if (required) {
         throw `Empty obj value passed: ${v}`
       }
       return def
-    }  
-    if (typeof v != 'object') {
+    }
+    if (typeof v !== "object") {
       throw `Wrong obj value passed: ${v}`
-    }  
-  
+    }
+
     return v
   }
-  
-  parse_field_obj(fields, name, required= false, def= undefined) {
-    if ( ! (name in fields)) {
+
+  parse_field_obj(fields, name, required = false, def = undefined) {
+    if (!(name in fields)) {
       if (required) {
-       throw `Expected obj value not passed for ${name}`
+        throw `Expected obj value not passed for ${name}`
       }
       return def
     }
-    return this.parse_value_obj(fields[name], required, def)
+    try {
+      return this.parse_value_obj(fields[name], required, def)
+    } catch (e) {
+      throw `parse_field_obj() Error for ${name}: ${e}`
+    }
   }
 }

package/src/engines/parser/index.mjs

@@ -1,6 +1,6 @@
 import Parser from "./Parser.mjs"
 
 export const init_parser = () => {
-  const p = new Parser() 
+  const p = new Parser()
   return p
 }

package/src/engines/schema/diffObjs.mjs

@@ -0,0 +1,41 @@
+export function diffObjs(o1, o2) {
+  const missingKeys = []
+
+  function findMissing(obj1, obj2, prefix = "") {
+    for (const key in obj1) {
+      if (Object.hasOwn(obj1, key)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key
+
+        if (!obj2 || !(key in obj2)) {
+          missingKeys.push(`'${fullKey}'`)
+        } else if (
+          typeof obj1[key] === "object" &&
+          obj1[key] !== null &&
+          typeof obj2[key] === "object" &&
+          obj2[key] !== null &&
+          !Array.isArray(obj1[key]) &&
+          !Array.isArray(obj2[key])
+        ) {
+          findMissing(obj1[key], obj2[key], fullKey)
+        }
+      }
+    }
+  }
+
+  findMissing(o1, o2)
+
+  if (missingKeys.length === 0) {
+    return ""
+  }
+
+  const isPlural = missingKeys.length > 1
+  let keysStr = ""
+  if (!isPlural) {
+    keysStr = missingKeys[0]
+  } else {
+    const lastKey = missingKeys.pop()
+    keysStr = `${missingKeys.join(", ")} and ${lastKey}`
+  }
+
+  return keysStr
+}

package/src/engines/schema/index.mjs

@@ -0,0 +1,4 @@
+import { with_miolo_input_schema } from "./input.mjs"
+import { with_miolo_output_schema } from "./output.mjs"
+
+export { with_miolo_input_schema, with_miolo_output_schema }

package/src/engines/schema/input.mjs

@@ -0,0 +1,54 @@
+import Joi from "joi"
+
+export function with_miolo_input_schema(fn, schema, options) {
+  return async (ctx, params) => {
+    let error
+
+    // Check schema is actually a schema
+    if (!schema || !Joi.isSchema(schema)) {
+      error = `Expecting input schema for ${fn.name} but something else was found (${typeof schema})`
+      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+      throw new Error(error)
+    }
+
+    // perform validation
+    let v
+    try {
+      v = schema.validate(params, {
+        ...(options || {})
+      })
+    } catch (uerror) {
+      error = `Unexpected error validating input data for ${fn.name}: ${uerror?.message || uerror}`
+      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+      throw new Error(error)
+    }
+
+    // raise validation errors
+    if (v?.error) {
+      error = `Input schema invalidated data for ${fn.name}: ${v.error}\n${v.error.annotate(true)}`
+      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+      throw new Error(error)
+    }
+
+    // check parsed value is ok
+    if (!v?.value) {
+      const description = schema.describe()
+
+      // Check if schema was deliberately set to allow only null
+      //  schema = Joi.any().allow(null)
+      const isOnlyNull =
+        description.type === "any" &&
+        description.allow &&
+        description.allow.length === 1 &&
+        description.allow[0] === null
+
+      if (!isOnlyNull) {
+        error = `Input schema returned unknown result for ${fn.name}: ${JSON.stringify(v)}`
+        ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+        throw new Error(error)
+      }
+    }
+
+    return await fn(ctx, v.value)
+  }
+}

package/src/engines/schema/output.mjs

@@ -0,0 +1,66 @@
+import Joi from "joi"
+import { diffObjs } from "./diffObjs.mjs"
+
+export function with_miolo_output_schema(fn, schema, options) {
+  const fnName = fn?.name ? `[${fn.name}]` : ""
+
+  return async (ctx, params) => {
+    let error
+
+    // Check schema is actually a schema
+    if (!schema || !Joi.isSchema(schema)) {
+      error = `Expecting output schema for ${fn.name} but something else was found (${typeof schema})`
+      ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+      throw new Error(error)
+    }
+
+    // Call the function first
+    const result = await fn(ctx, params)
+
+    // perform validation over the result
+    let v
+    try {
+      v = schema.validate(result, {
+        stripUnknown: true,
+        ...(options || {})
+      })
+    } catch (uerror) {
+      error = `Unexpected error validating output data for ${fn.name}: ${uerror?.message || uerror}`
+      ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+      throw new Error(error)
+    }
+
+    // raise validation errors
+    if (v?.error) {
+      error = `Output schema invalidated data for ${fn.name}: ${v.error}\n${v.error.annotate(true)}`
+      ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+      throw new Error(error)
+    }
+
+    // check parsed value is ok
+    if (!v?.value) {
+      const description = schema.describe()
+
+      // Check if schema was deliberately set to allow only null
+      //  schema = Joi.any().allow(null)
+      const isOnlyNull =
+        description.type === "any" &&
+        description.allow &&
+        description.allow.length === 1 &&
+        description.allow[0] === null
+
+      if (!isOnlyNull) {
+        error = `Output schema returned unknown result for ${fn.name}: ${JSON.stringify(v)}`
+        ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+        throw new Error(error)
+      }
+    }
+
+    const diff = diffObjs(result, v.value)
+    if (diff) {
+      ctx.miolo.logger.debug(`[validation]${fnName} Output schema has removed ${diff}`)
+    }
+
+    return v.value
+  }
+}