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

package/src/engines/cron/ipsum.mjs

@@ -1,12 +1,11 @@
-import path from 'path'
-import fs from 'fs'
-import https from 'https'
-//import fetch from 'node-fetch'
-import { cyan, green, yellow } from 'tinguir'
-
-const _IPSUM_DEF_FOLDER = '/var/ipsum'
-const _IPSUM_FILE_NAME = 'ipsum.txt'
-const _IPSUM_REMOTE_FILE = 'https://raw.githubusercontent.com/stamparm/ipsum/master/ipsum.txt'
+import fs from "node:fs"
+import https from "node:https"
+import path from "node:path"
+import { cyan, green, yellow } from "tinguir"
+
+const _IPSUM_DEF_FOLDER = "/var/ipsum"
+const _IPSUM_FILE_NAME = "ipsum.txt"
+const _IPSUM_REMOTE_FILE = "https://raw.githubusercontent.com/stamparm/ipsum/master/ipsum.txt"
 const _IPSUM_NLISTS = 1
 
 /*function ipsum_download_file(callback, remote_file = _IPSUM_REMOTE_FILE) {
@@ -17,118 +16,124 @@ const _IPSUM_NLISTS = 1
   })
 }*/
 
-
 export function ipsum_download_file(callback, remote_file = _IPSUM_REMOTE_FILE, logger) {
   const lerr = logger ? logger.error : console.error
 
-  https.get(remote_file, (res) => {
-    const data = []
-    res.on('data', (chunk) => {
-      data.push(chunk)
-    }).on('end', () => {
-      let content = Buffer.concat(data).toString()
-      callback(content)
+  https
+    .get(remote_file, (res) => {
+      const data = []
+      res
+        .on("data", (chunk) => {
+          data.push(chunk)
+        })
+        .on("end", () => {
+          const content = Buffer.concat(data).toString()
+          callback(content)
+        })
+    })
+    .on("error", (err) => {
+      lerr(`[cron][${cyan("IPsum")}] Error downloading remote file (${err.toString()})`)
+      callback("")
     })
-  }).on('error', (err) => {
-    lerr(`[cron][${cyan('IPsum')}] Error downloading remote file (${err.toString()})`)
-    callback('')
-  })
-
 }
 
 function _ipsum_ips_from_content(content, logger) {
   const lerr = logger ? logger.error : console.error
 
-  if (! content) {
+  if (!content) {
     return []
   }
 
   try {
-    let ips = []
+    const ips = []
     content
-      .split('\n')
-      .filter(line => line.indexOf('#') < 0)
-      .map(line => {
-        const [ip, nlists] = line.split('\t')
-        if (parseInt(nlists) >= _IPSUM_NLISTS) {
+      .split("\n")
+      .filter((line) => line.indexOf("#") < 0)
+      .forEach((line) => {
+        const [ip, nlists] = line.split("\t")
+        if (parseInt(nlists, 10) >= _IPSUM_NLISTS) {
           ips.push(ip)
         }
       })
     return ips
-  } catch(error) {
-    lerr(`[cron][${cyan('IPsum')}] Error getting IPs from content`)
+  } catch (_) {
+    lerr(`[cron][${cyan("IPsum")}] Error getting IPs from content`)
     return []
   }
 }
 
-function _ipsum_ips_from_file(folder= _IPSUM_DEF_FOLDER, logger) {
+function _ipsum_ips_from_file(folder = _IPSUM_DEF_FOLDER, logger) {
   const lerr = logger ? logger.error : console.error
 
-  if (! fs.existsSync(folder)) {
+  if (!fs.existsSync(folder)) {
     if (logger) {
-      lerr(`[cron][${cyan('IPsum')}] Folder ${folder} does not exist`)
+      lerr(`[cron][${cyan("IPsum")}] Folder ${folder} does not exist`)
     }
     return []
   }
 
   const local_path = path.join(folder, _IPSUM_FILE_NAME)
 
-  if (! fs.existsSync(local_path)) {
+  if (!fs.existsSync(local_path)) {
     if (logger) {
-      lerr(`[cron][${cyan('IPsum')}] File ${local_path} does not exist`)
+      lerr(`[cron][${cyan("IPsum")}] File ${local_path} does not exist`)
     }
     return []
   }
 
-  const content = fs.readFileSync(local_path, {encoding:'utf8'})  
+  const content = fs.readFileSync(local_path, { encoding: "utf8" })
   return _ipsum_ips_from_content(content, logger)
 }
 
-
-function ipsum_update(folder= _IPSUM_DEF_FOLDER, callback, logger) {
+function ipsum_update(folder = _IPSUM_DEF_FOLDER, callback, logger) {
   const lerr = logger ? logger.error : console.error
-  const ldbg = logger ? logger.debug : console.log
+  const linf = logger ? logger.info : console.log
 
-  if (! fs.existsSync(folder)) {
-    lerr(`[cron][${cyan('IPsum')}] Folder ${folder} does not exist`)
+  if (!fs.existsSync(folder)) {
+    lerr(`[cron][${cyan("IPsum")}] Folder ${folder} does not exist`)
     return
   }
 
   try {
-    ldbg(`[cron][${cyan('IPsum')}] Updating file...`)
+    linf(`[cron][${cyan("IPsum")}] Updating file...`)
 
     ipsum_download_file((content) => {
-      
       const local_path = path.join(folder, _IPSUM_FILE_NAME)
-      fs.writeFileSync(local_path, content, {encoding:'utf8', flag:'w'})
+      fs.writeFileSync(local_path, content, { encoding: "utf8", flag: "w" })
 
-      const ntot = content.split('\n').length
+      const ntot = content.split("\n").length
       const ips = _ipsum_ips_from_content(content, logger)
       const nfilt = ips.length
-      ldbg(`[cron][${cyan('IPsum')}] File downloaded. ${ntot} ips on the list (${nfilt} appearing in ${_IPSUM_NLISTS} or more lists)`)
-      
+      linf(
+        `[cron][${cyan("IPsum")}] File downloaded. ${ntot} ips on the list (${nfilt} appearing in ${_IPSUM_NLISTS} or more lists)`
+      )
+
       if (callback) {
         callback(ips)
       }
     })
-  
-  } catch(error) {
-    lerr(`[cron][${cyan('IPsum')}] Error ${error} updating the file`)
+  } catch (error) {
+    lerr(`[cron][${cyan("IPsum")}] Error ${error} updating the file`)
   }
 }
 
-
 export function ipsum_config() {
   return {
-    name: 'IPsum',
-    cronTime: '0 0 * * *',
+    name: "IPsum",
+    cronTime: "0 0 * * *",
     onTick: async (miolo, _onCompleted) => {
       const folder = miolo.config.http.ratelimit.ipsum_folder || _IPSUM_DEF_FOLDER
-      ipsum_update(folder, (ips) => {
-        miolo.logger.debug(`[cron][${cyan('IPsum')}] File downloaded. ${green(ips.length)} ips will be ${yellow('blacklisted')}!`)
-      }, miolo.logger)
+      ipsum_update(
+        folder,
+        (ips) => {
+          miolo.logger.debug(
+            `[cron][${cyan("IPsum")}] File downloaded. ${green(ips.length)} ips will be ${yellow("blacklisted")}!`
+          )
+        },
+        miolo.logger
+      )
     },
-    start: true   
+    start: true
   }
 }
 
@@ -141,10 +146,10 @@ export function ipsum_read_ips(folder = _IPSUM_DEF_FOLDER, callback, logger) {
     if (callback) {
       callback(ips)
     }
-    ldbg(`[cron][${cyan('IPsum')}] File contains ${ips.length} ips`)
+    ldbg(`[cron][${cyan("IPsum")}] File contains ${ips.length} ips`)
     return ips
   } else {
-    lwarn(`[cron][${cyan('IPsum')}] File is empty. Launching update...`)
+    lwarn(`[cron][${cyan("IPsum")}] File is empty. Launching update...`)
     ipsum_update(folder, callback, logger)
     return []
   }

package/src/engines/cron/syscheck.mjs

@@ -1,56 +1,56 @@
-import os from 'os'
-import diskspace from 'diskspace'
-import { cyan, green, yellow } from 'tinguir'
+import os from "node:os"
+import diskspace from "diskspace"
+import { cyan, green, yellow } from "tinguir"
 
 function _toMB(bytes) {
   if (!bytes) return 0
-  return bytes/1000000
+  return bytes / 1000000
 }
 
-
 function _toGB(kbytes) {
   if (!kbytes) return 0
-  return kbytes/1000000
+  return kbytes / 1000000
 }
 
-
-
 function _sys_check_and_log(logger) {
-  
-
-  const used= Math.round(_toMB(os.freemem()), 2)
-  const total= Math.round(_toMB(os.totalmem()), 2)
-  const perc= Math.round( (used*100)/total, 2)
-
-  if (perc>80) {
-    logger.error(`[cron][${cyan('SysCheck')}] RAM ${yellow(used)} MB used of ${green(total)} MB (${yellow(perc)} %)`)
+  const used = Math.round(_toMB(os.freemem()), 2)
+  const total = Math.round(_toMB(os.totalmem()), 2)
+  const perc = Math.round((used * 100) / total, 2)
+
+  if (perc > 80) {
+    logger.warn(
+      `[cron][${cyan("SysCheck")}] RAM ${yellow(used)} MB used of ${green(total)} MB (${yellow(perc)} %)`
+    )
   } else {
-    logger.info(`[cron][${cyan('SysCheck')}] RAM ${yellow(used)} MB used of ${green(total)} MB (${yellow(perc)} %)`)
+    logger.info(
+      `[cron][${cyan("SysCheck")}] RAM ${yellow(used)} MB used of ${green(total)} MB (${yellow(perc)} %)`
+    )
   }
-  
 
-  diskspace.check('/', function (err, result)
-  {
+  diskspace.check("/", (_err, result) => {
     const used = Math.round(_toGB(result.used), 2)
-    const total= Math.round(_toGB(result.total), 2)
+    const total = Math.round(_toGB(result.total), 2)
     const free = Math.round(_toGB(result.free), 2)
 
-    if (free<1) {
-      logger.error(`[cron][${cyan('SysCheck')}] DISK ${yellow(used)} GB used of ${green(total)} GB (${yellow(free)} GB free)`)
+    if (free < 1) {
+      logger.warn(
+        `[cron][${cyan("SysCheck")}] DISK ${yellow(used)} GB used of ${green(total)} GB (${yellow(free)} GB free)`
+      )
     } else {
-      logger.info(`[cron][${cyan('SysCheck')}] DISK ${yellow(used)} GB used of ${green(total)} GB (${yellow(free)} GB free)`)
+      logger.info(
+        `[cron][${cyan("SysCheck")}] DISK ${yellow(used)} GB used of ${green(total)} GB (${yellow(free)} GB free)`
+      )
     }
-  });  
+  })
 }
 
-
 export function sys_check_config() {
   return {
-    name: 'SysCheck',
-    cronTime: '0,15,30,45 * * * *',
+    name: "SysCheck",
+    cronTime: "0,15,30,45 * * * *",
     onTick: async (miolo, _onCompleted) => {
       _sys_check_and_log(miolo.logger)
     },
-    start: true   
+    start: true
   }
-}
+}

package/src/engines/emailer/index.mjs

@@ -1,2 +1 @@
-
-export {init_emailer_transporter} from './transporter.mjs'
+export { init_emailer_transporter } from "./transporter.mjs"

package/src/engines/emailer/queue.mjs

@@ -1,9 +1,9 @@
-import { v4 as uuidv4 } from 'uuid'
+import { v4 as uuidv4 } from "uuid"
 
-export let EMAIL_QUEUE = {}
+export const EMAIL_QUEUE = {}
 
-export async function email_queue_an_email(email, logger= undefined) {
-  const _loge = logger?.info || console.error
+export async function email_queue_an_email(email, logger = undefined) {
+  const _loge = logger?.error || console.error
 
   try {
     const id = uuidv4()
@@ -11,24 +11,22 @@ export async function email_queue_an_email(email, logger= undefined) {
     //await client.rPush('email_queue', JSON.stringify(emailData))
     EMAIL_QUEUE[id] = emailData
     return { ok: true, id }
-
   } catch (error) {
     _loge(`[emailer] Error al guardar en la cola: ${error}`)
     return { ok: false, id: null, error }
   }
 }
 
-export function email_queue_pop_pendings(logger= undefined) {
-
-  let grouped = {}
+export function email_queue_pop_pendings(_logger = undefined) {
+  const grouped = {}
 
   Object.values(EMAIL_QUEUE)
-    .filter(e => !e.sent)
-    .forEach(({ id: eid, from, to, subject }) => {
+    .filter((e) => !e.sent)
+    .forEach(({ id: eid, from, to, subject, text, html }) => {
       const key = `${from}_${to}_${subject}`
-      
+
       if (!grouped[key]) {
-        grouped[key] = { to_subject_key: key, from, to, subject, count: 0, ids: [] }
+        grouped[key] = { to_subject_key: key, from, to, subject, text, html, count: 0, ids: [] }
       }
 
       grouped[key].count++
@@ -36,19 +34,15 @@ export function email_queue_pop_pendings(logger= undefined) {
 
       // Mark as sent
       try {
-        EMAIL_QUEUE[eid].sent= true
-      } catch(_) {}
-  })
+        EMAIL_QUEUE[eid].sent = true
+      } catch (_) {}
+    })
 
-  
   return Object.values(grouped)
 }
 
-export function email_queue_remove_ids(eids, logger= undefined) {
+export function email_queue_remove_ids(eids, _logger = undefined) {
   eids.forEach((eid) => {
-
     delete EMAIL_QUEUE[eid]
   })
 }
-
-

package/src/engines/emailer/transporter.mjs

@@ -1,37 +1,35 @@
-import nodemailer from 'nodemailer'
-import { email_queue_an_email, email_queue_pop_pendings, email_queue_remove_ids } from './queue.mjs'
+import nodemailer from "nodemailer"
+import { email_queue_an_email, email_queue_pop_pendings, email_queue_remove_ids } from "./queue.mjs"
 
+const _logi = (logger, msg) => (logger?.info ? logger.info(msg) : console.log(msg))
+const _logs = (logger, msg) => (logger?.silly ? logger.silly(msg) : console.log(msg))
+const _loge = (logger, msg) => (logger?.error ? logger.error(msg) : console.error(msg))
 
-const _logi = (logger, msg) => logger?.info ? logger.info(msg) : console.info(msg)
-const _loge = (logger, msg) => logger?.error ? logger.info(msg) : console.error(msg)
-
-
-export function _init_emailer_transporter({options, defaults, silent}) {
-
+export function _init_emailer_transporter({ options, defaults, silent }) {
   const nmailer = nodemailer.createTransport(options, defaults)
 
-  function verify_emailer(logger= undefined) {
-    _logi(logger, '[emailer] Verifying...')
-    nmailer.verify(function(error, _success) {
+  function verify_emailer(logger = undefined) {
+    _logs(logger, "[emailer] Verifying...")
+    nmailer.verify((error, _success) => {
       if (error) {
-        _loge(logger, '[emailer] Verifying ERROR')
-        _loge(logger, error?.message || error?.stack || error || 'Unknown error')
+        _loge(logger, "[emailer] Verifying ERROR")
+        _loge(logger, error?.message || error?.stack || error || "Unknown error")
       } else {
-        _logi(logger, '[emailer] Verifyed OK: Server is ready to take our messages')
+        _logs(logger, "[emailer] Verifyed OK: Server is ready to take our messages")
       }
     })
   }
 
-  async function send_email(mail, logger= undefined) {
+  async function send_email(mail, logger = undefined) {
     if (silent === true) {
-      _logi(logger, '[emailer] *********************************')
-      _logi(logger, '[emailer] This mail will not be send (emailing is disabled):')
-      _logi(logger, `[emailer] From: ${mail?.from || '?'}`)
-      _logi(logger, `[emailer] To: ${mail?.to || '?'}`)
-      _logi(logger, `[emailer] Subject: ${mail?.subject || '?'}`)
-      _logi(logger, '[emailer] Mail body:')
-      _logi(logger, mail?.text || mail?.html || '--empty--')
-      _logi(logger, '[emailer] *********************************')
+      _logi(logger, "[emailer] *********************************")
+      _logi(logger, "[emailer] This mail will not be send (emailing is disabled):")
+      _logi(logger, `[emailer] From: ${mail?.from || "?"}`)
+      _logi(logger, `[emailer] To: ${mail?.to || "?"}`)
+      _logi(logger, `[emailer] Subject: ${mail?.subject || "?"}`)
+      _logi(logger, "[emailer] Mail body:")
+      _logi(logger, mail?.text || mail?.html || "--empty--")
+      _logi(logger, "[emailer] *********************************")
 
       return {
         ok: true,
@@ -41,12 +39,15 @@ export function _init_emailer_transporter({options, defaults, silent}) {
       }
     } else {
       try {
-        let info = await nmailer.sendMail(mail)
-        info.ok = info?.messageId ? true : false
+        const info = await nmailer.sendMail(mail)
+        info.ok = info?.messageId !== undefined
 
         return info
-      } catch(error) {
-        _loge(logger, `[emailer] Error sending email: ${mail?.from || ''} => ${mail?.to || ''} (${mail?.subject || ''})`)
+      } catch (error) {
+        _loge(
+          logger,
+          `[emailer] Error sending email: ${mail?.from || ""} => ${mail?.to || ""} (${mail?.subject || ""})`
+        )
 
         return {
           ok: false,
@@ -58,16 +59,16 @@ export function _init_emailer_transporter({options, defaults, silent}) {
     }
   }
 
-  function queue_email(mail, logger= undefined) {
+  function queue_email(mail, logger = undefined) {
     if (silent === true) {
-      _logi(logger, '[emailer] *********************************')
-      _logi(logger, '[emailer] This mail will not be queued (emailing is disabled):')
-      _logi(logger, `[emailer] From: ${mail?.from || '?'}`)
-      _logi(logger, `[emailer] To: ${mail?.to || '?'}`)
-      _logi(logger, `[emailer] Subject: ${mail?.subject || '?'}`)
-      _logi(logger, '[emailer] Mail body:')
-      _logi(logger, mail?.text || mail?.html || '--empty--')
-      _logi(logger, '[emailer] *********************************')
+      _logi(logger, "[emailer] *********************************")
+      _logi(logger, "[emailer] This mail will not be queued (emailing is disabled):")
+      _logi(logger, `[emailer] From: ${mail?.from || "?"}`)
+      _logi(logger, `[emailer] To: ${mail?.to || "?"}`)
+      _logi(logger, `[emailer] Subject: ${mail?.subject || "?"}`)
+      _logi(logger, "[emailer] Mail body:")
+      _logi(logger, mail?.text || mail?.html || "--empty--")
+      _logi(logger, "[emailer] *********************************")
 
       return {
         ok: true,
@@ -78,7 +79,10 @@ export function _init_emailer_transporter({options, defaults, silent}) {
     } else {
       try {
         const q = email_queue_an_email(mail, logger)
-        _logi(logger, `[emailer] Queued email: ${mail?.from || ''} => ${mail?.to || ''} (${mail?.subject || ''})`)
+        _logs(
+          logger,
+          `[emailer] Queued email: ${mail?.from || ""} => ${mail?.to || ""} (${mail?.subject || ""})`
+        )
 
         return {
           ok: q.ok,
@@ -86,8 +90,11 @@ export function _init_emailer_transporter({options, defaults, silent}) {
           error: q.error,
           messageId: q.id
         }
-      } catch(error) {
-        _loge(logger, `[emailer] Error queueing email: ${mail?.from || ''} => ${mail?.to || ''} (${mail?.subject || ''})`)
+      } catch (error) {
+        _loge(
+          logger,
+          `[emailer] Error queueing email: ${mail?.from || ""} => ${mail?.to || ""} (${mail?.subject || ""})`
+        )
 
         return {
           ok: false,
@@ -99,59 +106,64 @@ export function _init_emailer_transporter({options, defaults, silent}) {
     }
   }
 
-  async function queue_send_emails(logger= undefined) {
+  async function queue_send_emails(logger = undefined) {
     const pending = email_queue_pop_pendings(logger)
     if (pending.length <= 0) {
-      return
+      return 0
     }
-    _logi(logger, `[emailer] Sending emails queue (${pending.length} emails)`)
-  
-    // const emailString = await client.lPop('email_queue')
-    // if (!emailString) break
-    // const email = JSON.parse(emailString)
-  
-    for (const email of pending) {
-      if (email.count > 1) {
-        _logi(logger, `[emailer] Sending queued and stacked email [${email.subject}](x${email.count})...`)
-        email.subject = `${email.subject} (x${email.count})`
-      } else {
-        _logi(logger, `[emailer] Sending queued email [${email.subject}]...`)
-      }
-
-      send_email(email).then((res) => {
-        _logi(logger, `[emailer] Queued email [${email.subject}]sent ${res.ok ? 'OK' : 'NOT OK'}`)
-        if (res.ok) {
-          delete email_queue_remove_ids(email.ids, logger)
+    try {
+      _logi(logger, `[emailer] Sending emails queue (${pending.length} emails)`)
+
+      // const emailString = await client.lPop('email_queue')
+      // if (!emailString) break
+      // const email = JSON.parse(emailString)
+
+      for (const email of pending) {
+        if (email.count > 1) {
+          _logs(
+            logger,
+            `[emailer] Sending queued and stacked email [${email.subject}](x${email.count})...`
+          )
+          email.subject = `${email.subject} (x${email.count})`
+        } else {
+          _logs(logger, `[emailer] Sending queued email [${email.subject}]...`)
         }
-      })
+
+        send_email(email).then((res) => {
+          _logs(logger, `[emailer] Queued email [${email.subject}]sent ${res.ok ? "OK" : "NOT OK"}`)
+          if (res.ok) {
+            delete email_queue_remove_ids(email.ids, logger)
+          }
+        })
+      }
+      _logs(logger, `[emailer] Sent emails ${pending.length} from queue`)
+      return pending.length
+    } catch (error) {
+      _loge(logger, `[emailer] Error sending emails queue: ${error}`)
+      return -1
     }
-    _logi(logger, `[emailer] Sent emails ${pending.length} from queue`)
   }
-  
-  const emailer= {
-    send: send_email, 
+
+  const emailer = {
+    send: send_email,
     verify: verify_emailer,
     queue_email,
     queue_send_emails,
-    options, 
-    defaults, 
+    options,
+    defaults,
     silent
   }
   return emailer
 }
 
+const _cache = {}
 
-
-let _cache = {}
-
-export function init_emailer_transporter({options, defaults, silent}, logger= undefined) {
-
-  const ckey = JSON.stringify({options, defaults, silent})
+export function init_emailer_transporter({ options, defaults, silent }, logger = undefined) {
+  const ckey = JSON.stringify({ options, defaults, silent })
   if (ckey in _cache) {
     return _cache[ckey]
   }
 
-  _cache[ckey] = _init_emailer_transporter({options, defaults, silent}, logger) 
+  _cache[ckey] = _init_emailer_transporter({ options, defaults, silent }, logger)
   return _cache[ckey]
-
 }