miolo 3.0.0-beta.13 → 3.0.0-beta.131

package/src/config/env.mjs

@@ -0,0 +1,52 @@
+import { config } from '@dotenvx/dotenvx'
+import path from 'node:path'
+import { existsSync } from 'node:fs'
+import { intre_locale_init } from 'intre'
+import { getInfoFromPkg, findClosestPackageJson } from './util.mjs'
+
+function _get_miolo_config_path(proyEnvPath, appName) {
+  const mioloEnv = appName=='miolo-demo'
+    ? '../miolo/src/config/.env'
+    : 'node_modules/miolo/src/config/.env'
+
+  const mioloPath = path.join(proyEnvPath, mioloEnv)
+  if (existsSync(mioloPath)) {
+    return mioloPath
+  }
+  return null
+}
+
+function _get_miolo_config_path_on_build(proyEnvPath, srvDest) {
+  
+  const mioloPath = path.join(proyEnvPath, srvDest, '.env')
+  if (existsSync(mioloPath)) {
+    return mioloPath
+  }
+  return null
+}
+
+
+export function init_env_config() {
+  intre_locale_init(process.env.MIOLO_INTRE_LOCALE)  
+
+  const proyEnvPath = findClosestPackageJson(process.cwd())
+  const [appName, srvDest] = getInfoFromPkg(proyEnvPath)
+  const debug = process.env.DOTENVX_DEBUG === 'true'
+
+  // miolo defaults
+  const libEnvPath = _get_miolo_config_path(proyEnvPath, appName)
+  if (libEnvPath) {
+    config({ path: libEnvPath, debug })
+  }
+
+  // Maybe miolo defs are on proyect's build folder
+  const buildEnvPath = _get_miolo_config_path_on_build(proyEnvPath, srvDest)
+  if (buildEnvPath) {
+    config({ path: buildEnvPath, debug })
+  }
+  
+  // proyect root config
+  if (proyEnvPath) {
+    config({ path: path.join(proyEnvPath, '.env'), override: true, debug })
+  }
+}

package/src/config/index.mjs

@@ -1,5 +1,7 @@
 import merge from 'deepmerge'
-import base_config from './defaults.mjs'
+import { init_env_config } from './env.mjs'
+import make_config_defaults from './defaults.mjs'
+import {isPlainObject} from 'is-plain-object'
 
 function _get_auth_type(config) {
   if (config?.auth?.basic) {
@@ -18,15 +20,20 @@ function _get_auth_type(config) {
 }
 
 
-function init_config(config) {
-  const all_config= merge(base_config, config)
-  
-  all_config.auth_type = _get_auth_type(config)
+export function init_config(makeConfig) {
+  // Init environment vars
+  init_env_config()
+
+  // delay import of defaults, so env vars can be there
+  const base_config = make_config_defaults()
+  const custom_config = makeConfig()
+
+  // isMergeableObject: objects like Joi schemas should be copied not merged
+  const all_config= merge(base_config, custom_config, {isMergeableObject: isPlainObject})
+
+  // Some addendum
+  all_config.auth_type = _get_auth_type(all_config)
   all_config.use_catcher = all_config?.http?.catcher_url ? true : false
-  
+
   return all_config
 }
-
-export {
-  init_config
-}

package/src/config/util.mjs

@@ -0,0 +1,41 @@
+import {readFileSync, existsSync} from 'node:fs'
+import path from 'node:path'
+
+export function getInfoFromPkg(pkgPath) {
+  try {
+    const packageJsonPath = path.join(pkgPath, 'package.json')
+    const content = readFileSync(packageJsonPath, 'utf8')
+    const packageData = JSON.parse(content)
+    const appName = packageData.name
+
+    let srvDest = './dist/server'
+    try {
+      const start = packageData.scripts.start
+      if (start) {
+        const regex = /^node\s+(.*?)\/run\.mjs(?:$|\s)/;
+        const match = start.match(regex);
+        if (match) {
+          srvDest = match[1]
+        }
+      }
+    } catch(err) {
+      console.error('[miolo] Error reading <start> package.json:', err)
+    }
+    
+    return [appName, srvDest]
+  } catch (error) {
+    console.error('[miolo] Error reading <name> package.json:', error)
+    return ['miolo', './dist/server']
+  }
+}
+
+export function findClosestPackageJson(dir) {
+  if (existsSync(path.join(dir, 'package.json'))) {
+    return dir
+  }
+  const parentDir = path.dirname(dir)
+  if (parentDir === dir) {
+    return null
+  }
+  return findClosestPackageJson(parentDir)
+}

package/src/engines/emailer/queue.mjs

@@ -3,7 +3,7 @@ import { v4 as uuidv4 } from 'uuid'
 export let EMAIL_QUEUE = {}
 
 export async function email_queue_an_email(email, logger= undefined) {
-  const _loge = logger?.info || console.error
+  const _loge = logger?.error || console.error
 
   try {
     const id = uuidv4()
@@ -18,7 +18,8 @@ export async function email_queue_an_email(email, logger= undefined) {
   }
 }
 
-export function email_queue_pop_pendings(logger= undefined) {
+/* eslint-disable no-unused-vars */
+export function email_queue_pop_pendings(logger= undefined) { 
 
   let grouped = {}
 

package/src/engines/emailer/transporter.mjs

@@ -2,8 +2,9 @@ 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.info(msg)
-const _loge = (logger, msg) => logger?.error ? logger.info(msg) : console.error(msg)
+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)
 
 
 export function _init_emailer_transporter({options, defaults, silent}) {
@@ -11,13 +12,13 @@ export function _init_emailer_transporter({options, defaults, silent}) {
   const nmailer = nodemailer.createTransport(options, defaults)
 
   function verify_emailer(logger= undefined) {
-    _logi(logger, '[emailer] Verifying...')
+    _logs(logger, '[emailer] Verifying...')
     nmailer.verify(function(error, _success) {
       if (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')
       }
     })
   }
@@ -78,7 +79,7 @@ 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,
@@ -112,20 +113,20 @@ export function _init_emailer_transporter({options, defaults, silent}) {
   
     for (const email of pending) {
       if (email.count > 1) {
-        _logi(logger, `[emailer] Sending queued and stacked email [${email.subject}](x${email.count})...`)
+        _logs(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}]...`)
+        _logs(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'}`)
+        _logs(logger, `[emailer] Queued email [${email.subject}]sent ${res.ok ? 'OK' : 'NOT OK'}`)
         if (res.ok) {
           delete email_queue_remove_ids(email.ids, logger)
         }
       })
     }
-    _logi(logger, `[emailer] Sent emails ${pending.length} from queue`)
+    _logs(logger, `[emailer] Sent emails ${pending.length} from queue`)
   }
   
   const emailer= {

package/src/engines/http/index.mjs

@@ -69,7 +69,7 @@ export function init_http_server(app, config) {
     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

package/src/engines/parser/Parser.mjs

@@ -18,7 +18,11 @@ export default class Parser {
       }
       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) {
@@ -40,7 +44,11 @@ export default class Parser {
       }
       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) {
@@ -62,8 +70,11 @@ export default class Parser {
       }
       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) {
@@ -90,8 +101,11 @@ export default class Parser {
       }
       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) {
@@ -121,6 +135,10 @@ export default class Parser {
       }
       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/schema/index.mjs

@@ -0,0 +1,40 @@
+import Joi from "joi"
+
+export function with_miolo_schema(fn, schema) {
+  return async function (ctx, params) {
+    let error
+
+    // Check schema is actually a schema
+    if ((!schema) || (! Joi.isSchema(schema))) {
+      error = `Expecting 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)
+    } catch(uerror) {
+      error = `Unexpected error validating 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 = `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) {
+      error = `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/index.mjs

@@ -3,6 +3,7 @@ import { miolo_cron } from './server-cron.mjs'
 import { init_emailer_transporter as miolo_emailer} from './engines/emailer/index.mjs'
 import { init_logger as miolo_logger } from './engines/logger/index.mjs'
 import { init_parser as miolo_parser } from './engines/parser/index.mjs'
+import { with_miolo_schema } from './engines/schema/index.mjs'
 
 import { cacheiro as miolo_cacher} from 'cacheiro'
 import { getConnection as miolo_db_connection} from 'calustra/conn-postgres'
@@ -14,5 +15,6 @@ export {
   miolo_logger,
   miolo_parser,
   miolo_cacher,
-  miolo_db_connection
+  miolo_db_connection,
+  with_miolo_schema
 }

package/src/middleware/auth/basic.mjs

@@ -52,8 +52,11 @@ const init_basic_auth_middleware = ( app, options ) => {
       }
 
       ctx.body= {
-        user: undefined,
-        authenticated: false
+        ok: true,
+        data: {
+          user: undefined,
+          authenticated: false
+        }
       }
       ctx.response.status= 401
       ctx.response.headers['WWW-Authenticate']= 'Basic realm="' + realm.replace(/"/g, '\\"') + '"'

package/src/middleware/auth/credentials/index.mjs

@@ -12,14 +12,14 @@ import { init_session_middleware } from './session/index.mjs'
 // }
 
 
-const def_get_user_id = (user, done, miolo) => done(null, user.id)
+const def_get_user_id = (user, done, ctx) => done(null, user.id)
 
-const def_find_user_by_id = (id, done, miolo) => {
+const def_find_user_by_id = (id, done, ctx) => {
   const err = Error('You need to define auth.passport.find_user_by_id')
   done(err, null)
 }
 
-const def_local_auth_user = (username, password, done, miolo) => {
+const def_local_auth_user = (username, password, done, ctx) => {
   const err = Error('You need to define auth.passport.local_auth_user')
   done(err, null)
 }
@@ -39,29 +39,48 @@ const init_credentials_auth_middleware = ( app, options, sessionConfig, cacheCon
   const url_logout_f = url_logout || '/logout'
   
   // init passport
-  const serialize_user = (user, done) => {
+  const serialize_user = (ctx) => (user, done) => {
     process.nextTick(function() {
-      get_user_id_f(user, done, app.context.miolo)
+      try {
+        ctx.miolo.logger.debug(`[auth] serializing user...`)
+        ctx.sessionId = ctx.session?.externalKey ? ctx.getSessionStoreKey(ctx.session?.externalKey) : undefined
+        return get_user_id_f(user, done, ctx)
+      } catch(error) {
+        ctx.miolo.logger.error(`[auth] Error serializing user: ${error}`)
+        return done(error, null)
+      }
     })
   }
 
-  const deserialize_user = (id, done) => {
+  const deserialize_user = (ctx) => (id, done) => {
     process.nextTick(function() {
-      find_user_by_id_f(id, done, app.context.miolo)
+      try {
+        ctx.miolo.logger.debug(`[auth] deserializing user...`)
+        ctx.sessionId = ctx.session?.externalKey ? ctx.getSessionStoreKey(ctx.session?.externalKey) : undefined
+        return find_user_by_id_f(id, done, ctx)
+      } catch(error) {
+        ctx.miolo.logger.error(`[auth] Error deserializing user: ${error}`)
+        return done(error, null)
+      }
     })
   }
 
-  const local_strategy= new LocalStrategy.Strategy (
+  const local_strategy= (ctx) => new LocalStrategy.Strategy (
     (username, password, done) => {
-      local_auth_user_f(username, password, done, app.context.miolo)
+      ctx.sessionId = ctx.session?.externalKey ? ctx.getSessionStoreKey(ctx.session?.externalKey) : undefined
+      return local_auth_user_f(username, password, done, ctx)
   })
 
-  init_session_middleware(app, sessionConfig, cacheConfig)
+  app.use((ctx, next) => {
+    passport.serializeUser(serialize_user(ctx));
+    passport.deserializeUser(deserialize_user(ctx));
+    passport.use(local_strategy(ctx));
+    return next();
+  });
   
-  passport.serializeUser(serialize_user)
-  passport.deserializeUser(deserialize_user)
-  passport.use(local_strategy)
 
+  init_session_middleware(app, sessionConfig, cacheConfig)
+  
   app.use(passport.initialize())
   app.use(passport.session())
 
@@ -70,7 +89,7 @@ const init_credentials_auth_middleware = ( app, options, sessionConfig, cacheCon
       if (ctx.session.authenticated) {
         ctx.session.user = ctx.state.user
       }
-    } catch(_) {}
+    } catch(_) {}  
     await next()
   }
   app.use(_ensure_ctx_user)
@@ -81,34 +100,38 @@ const init_credentials_auth_middleware = ( app, options, sessionConfig, cacheCon
       if (user === false) {
         ctx.session.user = undefined
         ctx.session.authenticated = false
-
-        ctx.body = { 
-          user: undefined,
-          authenticated: false,
-          info: info,
-          error: err
-        }
+        ctx.sessionId = undefined
 
         // This will show error logs on the catcher middleware
         // ctx.throw(401)
         
-        ctx.response.status= 401
-      } else {
+        ctx.status= 401
 
-        ctx.session.user = ctx.state.user
+        ctx.body = { 
+          ok: err==undefined,
+          data: {
+            user: undefined,
+            authenticated: false,
+            info: info,
+          },
+          error: err
+        }
+      } else {
+        await ctx.login(user)
+        ctx.session.user = user // ctx.state.user
         ctx.session.authenticated = true
-
+        
         ctx.body = { 
-          user : user,
-          authenticated: true
+          ok: true,
+          data: {
+            user : user,
+            authenticated: true
+          }
         }
+
         if (url_login_redirect!=undefined) {
           ctx.redirect(url_login_redirect)
         }
-
-        const res= await ctx.login(user)
-
-        return res
       }
     })(ctx)
   }
@@ -117,25 +140,33 @@ const init_credentials_auth_middleware = ( app, options, sessionConfig, cacheCon
     if (ctx.session.authenticated) {
       ctx.session.user = undefined
       ctx.session.authenticated = false
+      ctx.sessionId = undefined
 
-      await ctx.logout()
       ctx.body = { 
-        user: undefined,
-        authenticated: false 
-      }      
+        ok: true,
+        data: {
+          user: undefined,
+          authenticated: false 
+        }
+      }
+        
       if (url_logout_redirect!=undefined) {
         ctx.redirect(url_logout_redirect)
-      }
+      } else {
+        await ctx.logout()
+      }  
     } else {
-
-      ctx.body = { 
-        user: undefined,
-        authenticated: false 
-      }
       // This will show error logs on the catcher middleware
       // ctx.throw(401)
       
-      ctx.response.status= 401
+      ctx.status= 401
+      ctx.body = { 
+        ok: true,
+        data: {
+          user: undefined,
+          authenticated: false 
+        }
+      }
     }
   }
   
@@ -145,7 +176,8 @@ const init_credentials_auth_middleware = ( app, options, sessionConfig, cacheCon
   login_router.get (url_logout_f, handleLogOut)
   login_router.post(url_logout_f, handleLogOut)
   
-  app.use(login_router.routes())
+  app.use(login_router.routes()) 
+
 }
 
 export {init_credentials_auth_middleware}

package/src/middleware/auth/credentials/session/index.mjs

@@ -19,6 +19,13 @@ function init_session_middleware(app, sessionConfig, cacheConfig) {
   }
   
   app.use(createSession(options, app))
+  
+  app.use (async (ctx, next) => {
+    ctx.getSessionStoreKey = (externalKey) => {
+      return store.getInnerKey(externalKey)
+    }
+    await next()
+  })
 }
 
 export {init_session_middleware}

package/src/middleware/auth/credentials/session/store.mjs

@@ -49,11 +49,20 @@ class SessionStore {
     const cache = await this.init_cache()
     await cache.unsetItem(key)
   }
+
+  getInnerKey(key) {
+    if (this._cache === undefined) {
+      this.logger.error('[session-store] Calling getInnerKey() before cache is inited')
+      return key
+    }
+    return this._cache.getInnerKey(key)
+  }
 }
 
 
 export function init_session_cache_store(cacheConfig, logger) {
   const options = miolo_cacher_options_for_session({cache: cacheConfig}, logger)
   const store = new SessionStore(options, logger)
+  store.init_cache()
   return store
 }

package/src/middleware/context/index.mjs

@@ -32,4 +32,4 @@ const init_context_middleware = ( app, config ) => {
   app.context.miolo= mioloContext
 }
 
-export { init_context_middleware }
+export { init_context_middleware }