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

package/src/engines/socket/index.mjs

@@ -1,5 +1,4 @@
-//import IO from 'koa-socket-2'
-import { Server } from 'socket.io'
+import { Server } from "socket.io"
 
 function init_socket(app, config) {
   if (config?.enabled !== true) {
@@ -8,60 +7,59 @@ function init_socket(app, config) {
 
   const logger = app.context.miolo.logger
 
-  logger.info('[socket] Attaching Socket server')
+  logger.info("[socket] Attaching Socket server")
 
   const io = new Server(app.http.server)
 
-  io.on('connection', function (socket) {
-    logger.debug(`[socket] Connection from ... `) // ${i.ip} ${i.id}`)
-    
+  if (config?.userRooms === true) {
+    io.use(async (socket, next) => {
+      try {
+        const { store, options } = app.context.miolo.session || {}
+        if (store && options) {
+          // Create a fake Koa context to easily parse the signed cookies
+          const ctx = app.createContext(
+            socket.request,
+            socket.request.res || { headersSent: false }
+          )
+
+          // Read the session cookie (Koa handles signature validation if options.signed is true)
+          const sessionCookieValue = ctx.cookies.get(options.key, options)
+
+          if (sessionCookieValue) {
+            // If the cookie is present, koa-session stores the external key directly
+            // or sometimes it's base64 encoded. koa-session's decode function:
+            const sessionId = sessionCookieValue
+
+            const session = await store.get(sessionId, undefined, {})
+
+            if (session?.user) {
+              const userId = session.user?.id
+              socket.join(`user_${userId}`)
+              socket.mioloUser = userId // Attach for convenience
+              logger.info(`[socket] Socket ${socket.id} joined room user_${userId}`)
+            }
+          }
+        }
+      } catch (err) {
+        logger.error(`[socket] Error parsing session: ${err.message}`)
+      }
+      next()
+    })
+  }
+
+  io.on("connection", (socket) => {
+    logger.info(`[socket] Connection from ... `) // ${i.ip} ${i.id}`)
+
     if (config?.connection) {
       config.connection(socket)
     }
-    
+
     for (const ns of config?.namespaces || []) {
       socket.on(ns.name, ns.listener)
     }
   })
-  
-
-  //  const getInfo = (ctx) => {
-  //    let i= {id: '', ip: ''}
-  //    try { 
-  //      i.id = ctx.socket.id
-  //    } catch (e) {}
-  //    try {
-  //      i.ip = ctx.socket.handshake.address
-  //    } catch (e) {}
-  //    return i
-  //  }
-
-  // const io = new IO({ origins: '*:*'})
-
-  //  io.on('connection', function (ctx, data) {
-  //    const logger = ctx.miolo.logger
-  //    const i= getInfo(ctx)
-  //    logger.warn(`[socket] Connection from ${i.ip} ${i.id}`)
-  //    if (config?.connection) {
-  //      config.connection(ctx, data)
-  //    }
-  //  })
-
-  //  io.on('disconnect', function (ctx, data) {
-  //    const logger = ctx.miolo.logger
-  //    const i = getInfo(ctx)
-  //    logger.warn(`[socket] Disconnected ${i.ip} ${i.id} => ${data}`)
-  //  })
-  //
-  //  io.on('error', function (ctx, data) {
-  //    const logger = ctx.miolo.logger
-  //    const i = getInfo(ctx)
-  //    logger.error(`[socket] Error on ${i.ip} ${i.id} => ${data}`)
-  //  })
-  //
-  //
-  //  io.attach(app)  
 
+  app.context.miolo.io = io
 }
 
-export {init_socket}
+export { init_socket }

package/src/index.mjs

@@ -1,18 +1,23 @@
-import { miolo } from './server.mjs'
-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 { cacheiro as miolo_cacher } from "cacheiro"
+import { miolo_db_connection_pg, miolo_db_drop_connections } from "./db-conn.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_input_schema, with_miolo_output_schema } from "./engines/schema/index.mjs"
+import { miolo } from "./server.mjs"
+import { miolo_cron } from "./server-cron.mjs"
 
-import { cacheiro as miolo_cacher} from 'cacheiro'
-import { getConnection as miolo_db_connection} from 'calustra/conn-postgres'
+// import { getConnection as miolo_db_connection_sqlite} from 'calustra/conn-sqlite'
 
 export {
   miolo,
+  miolo_cacher,
   miolo_cron,
+  miolo_db_connection_pg,
+  miolo_db_drop_connections,
   miolo_emailer,
   miolo_logger,
   miolo_parser,
-  miolo_cacher,
-  miolo_db_connection
-}
+  with_miolo_input_schema,
+  with_miolo_output_schema
+}

package/src/middleware/auth/basic.mjs

@@ -1,38 +1,37 @@
-import koa_mount from 'koa-mount'
+import koa_mount from "koa-mount"
 
-const _get_credentials = (req) => {
-  let sauth= req?.headers?.authorization
+const _get_basic_credentials = (req) => {
+  let sauth = req?.headers?.authorization
 
-  if (! sauth) {
+  if (!sauth) {
     return undefined
   }
-  
+
   try {
-    sauth= sauth.replace('Basic ', '')
-    try  {
-      sauth= Buffer.from(sauth, 'base64').toString()
-    } catch(_) {
-      sauth= atob(sauth)
+    sauth = sauth.replace("Basic ", "")
+    try {
+      sauth = Buffer.from(sauth, "base64").toString()
+    } catch (_) {
+      sauth = atob(sauth)
     }
-    const [username, password]= sauth.split(':')
-    return {username, password}
-
-  } catch(_) {
+    const [username, password] = sauth.split(":")
+    return { username, password }
+  } catch (_) {
     return undefined
   }
 }
 
-const init_basic_auth_middleware = ( app, options ) => {
-  let {auth_user, realm, paths} = options
-  if (! realm) {
-    realm = 'Secure Area'
+const init_basic_auth_middleware = (app, options) => {
+  let { auth_user, realm, paths } = options
+  if (!realm) {
+    realm = "Secure Area"
   }
 
   async function basic_auth_middleware(ctx, next) {
-    let au_user
+    let aaccount
     try {
-      au_user= _get_credentials(ctx.request)
-    } catch(_) {}
+      aaccount = _get_basic_credentials(ctx.request)
+    } catch (_) {}
 
     const unauth_err = () => {
       // This will show error logs on the catcher middleware
@@ -46,45 +45,47 @@ const init_basic_auth_middleware = ( app, options ) => {
       //  }
       //)
 
-      ctx.session= {
+      ctx.session = {
         user: undefined,
-        authenticated: false
+        authenticated: false,
+        auth_method: undefined
       }
 
-      ctx.body= {
-        user: undefined,
-        authenticated: false
+      ctx.body = {
+        ok: true,
+        data: {
+          user: undefined,
+          authenticated: false
+        }
       }
-      ctx.response.status= 401
-      ctx.response.headers['WWW-Authenticate']= 'Basic realm="' + realm.replace(/"/g, '\\"') + '"'
+      ctx.response.status = 401
+      ctx.response.headers["WWW-Authenticate"] = 'Basic realm="' + realm.replace(/"/g, '\\"') + '"'
     }
 
-    if (! au_user) {
+    if (!aaccount) {
       return unauth_err()
     }
-    
-    const user = await auth_user(au_user.username, au_user.password, app.context.miolo)
 
-    if (user === false || user == undefined) {
+    const user = await auth_user(aaccount.username, aaccount.password, ctx)
+
+    if (user === false || user === undefined || user === null) {
       return unauth_err()
     }
 
-    ctx.session= {
+    ctx.session = {
       user,
-      authenticated: true
+      authenticated: true,
+      auth_method: "basic"
     }
 
     await next()
   }
 
-  if (paths == undefined || paths.length == 0) {
+  if (paths === undefined || paths.length === 0) {
     app.use(basic_auth_middleware)
   } else {
-    paths.map(p => 
-      app.use(koa_mount(p, basic_auth_middleware))
-    )
+    paths.map((p) => app.use(koa_mount(p, basic_auth_middleware)))
   }
-
 }
 
-export {init_basic_auth_middleware}
+export { init_basic_auth_middleware }

package/src/middleware/auth/custom.mjs

@@ -1,29 +1,26 @@
+import Router from "@koa/router"
 
-import Router from '@koa/router'
-
-const init_custom_auth_middleware = ( app, callback ) => {
-  const logger= app.context.miolo.logger
+const init_custom_auth_middleware = (app, callback) => {
+  const logger = app.context.miolo.logger
 
   try {
+    const custom_auth_middleware = callback(app)
 
-    const custom_auth_middleware= callback(app)
-
-    if (typeof custom_auth_middleware === 'function') {
+    if (typeof custom_auth_middleware === "function") {
       app.use(custom_auth_middleware)
     } else if (Array.isArray(custom_auth_middleware)) {
-      const custom_auth_router= new Router()
+      const custom_auth_router = new Router()
 
-      custom_auth_middleware.map((r) => {
-        const method= r.method.toLowerCase()
+      custom_auth_middleware.forEach((r) => {
+        const method = r.method.toLowerCase()
         custom_auth_router[method](r.url, r.callback)
       })
 
       app.use(custom_auth_router.routes())
     }
-
-  } catch(err) {
+  } catch (err) {
     logger.error(`Custom auth error: ${err}'`)
   }
 }
 
-export {init_custom_auth_middleware}
+export { init_custom_auth_middleware }

package/src/middleware/auth/guest.mjs

@@ -1,26 +1,28 @@
-import jwt from 'jwt-simple'
+import jwt from "jwt-simple"
 
 function _guest_token_make_with_jwt(session, logger) {
-  const buid= Math.random().toString()
+  const buid = Math.random().toString()
   let secret = session?.secret
   if (!secret) {
-    secret= 'miolo_unsafe_secret'
-    logger.error('Guest token made with an unsafe secret string. Please, configure your own through session.secret.')
+    secret = "miolo_unsafe_secret"
+    logger.error(
+      "Guest token made with an unsafe secret string. Please, configure your own through session.secret."
+    )
   }
-  
+
   const payload = {
-    admin  : false,
-    buid   : buid
+    admin: false,
+    buid: buid
   }
   return jwt.encode(payload, secret)
 }
 
 function _get_cookie_properties(session) {
   let maxAge = session?.options?.maxAge
-  if (isNaN(maxAge)) {
-    maxAge= 86400
+  if (Number.isNaN(Number(maxAge))) {
+    maxAge = 86400
   }
-  let expires = new Date()
+  const expires = new Date()
   expires.setSeconds(expires.getSeconds() + maxAge)
 
   return {
@@ -29,47 +31,45 @@ function _get_cookie_properties(session) {
   }
 }
 
+const init_guest_auth_middleware = (app, options, session) => {
+  const logger = app.context.miolo.logger
 
-const init_guest_auth_middleware = ( app, options, session ) => {
-  const logger= app.context.miolo.logger
-  
   const _make_guest_token = () => {
     try {
-      let {make_guest_token} = options
-      if (make_guest_token!=undefined) {
+      const { make_guest_token } = options
+      if (make_guest_token !== undefined) {
         return make_guest_token(session || {})
       }
-    } catch(_) {}
+    } catch (_) {}
 
     return _guest_token_make_with_jwt(session || {}, logger)
   }
 
   async function guest_auth_middleware(ctx, next) {
-
     // Try to get our token from headers (server) or cookies (client)
-    let token= ctx.cookies.get('token') || ctx.headers['token']
+    let token = ctx.cookies.get("token") || ctx.headers.token
 
-    if (token===undefined || token.length==0) {
+    if (token === undefined || token.length === 0) {
       token = await _make_guest_token()
       logger.debug(`Guest token conceeded`)
     }
 
-    const options= _get_cookie_properties(session)
-    ctx.cookies.set('token', token, options)
+    const options = _get_cookie_properties(session)
+    ctx.cookies.set("token", token, options)
 
-    ctx.session= {
+    ctx.session = {
       user: {
-        name: 'guest'
+        name: "guest"
       },
       authenticated: true,
+      auth_method: "guest",
       token
-    }    
-    
+    }
+
     await next()
   }
 
   app.use(guest_auth_middleware)
-
 }
 
-export {init_guest_auth_middleware}
+export { init_guest_auth_middleware }