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

package/src/middleware/routes/router/crud/getCrudConfig.mjs

@@ -1,11 +1,6 @@
-import merge from 'deepmerge'
+import merge from "deepmerge"
 
-import {
-  DEFAULT_AUTH_USER,
-  DEFAULT_USE_USER_FIELDS,
-  DEFAULT_BEFORE_CALLBACK,
-  DEFAULT_AFTER_CALLBACK
-} from "../defaults.mjs"
+import { DEFAULT_AUTH_USER, DEFAULT_USE_USER_FIELDS } from "../defaults.mjs"
 
 /**
   [{
@@ -13,8 +8,8 @@ import {
 
     auth,
     bodyField,
-    before: (ctx) => {return goon/!goon},
-    after : (ctx, result) => {return result},
+    before: (ctx) => {return goon/!goon} or array of functions,
+    after : (ctx, data) => {return data} or array of functions,
     
     routes: an array of tables config, where each config can be:
       - a simple string with the table name
@@ -35,95 +30,76 @@ import {
 
           auth,
           bodyField,
-          before: (ctx) => {return goon/!goon},
-          after : (ctx, result) => {return result},
+          before: (ctx) => {return goon/!goon} or array of functions,
+          after : (ctx, data) => {return data} or array of functions,
     
         }      
   }]
 */
 
 const getCrudConfig = (config) => {
+  const cruds = config?.crud || []
 
-  const cruds= config?.crud || []
-
-  if (! cruds) {
+  if (!cruds) {
     return []
   }
 
-
-  if (! Array.isArray(cruds)) {
+  if (!Array.isArray(cruds)) {
     return []
   }
 
-  let output= []
-  
-  cruds.map((crud) => {      
-    const routes= crud?.routes
+  const output = []
+
+  cruds.forEach((crud) => {
+    const routes = crud?.routes
 
-    if (! routes) {
+    if (!routes) {
       return
     }
 
-    if (! Array.isArray(routes)) {
+    if (!Array.isArray(routes)) {
       return
     }
-    
+
     const comm_bodyField = crud?.bodyField || config?.bodyField
-    const comm_before = crud?.before || config?.before || DEFAULT_BEFORE_CALLBACK
-    const comm_after = crud?.after || config?.after || DEFAULT_AFTER_CALLBACK
+    const comm_before = crud?.before || config?.before
+    const comm_after = crud?.after || config?.after
 
+    const comm_auth = merge.all([DEFAULT_AUTH_USER, config?.auth || {}, crud?.auth || {}])
 
-    const comm_auth= merge.all([
-      DEFAULT_AUTH_USER,
-      config?.auth || {},
-      crud?.auth || {}
-    ])
-    
-    let parsed_routes= []
+    const parsed_routes = []
 
     for (const troute of routes) {
+      const route = typeof troute === "string" ? { name: troute } : troute
 
-      const route = (typeof troute === 'string')
-        ? {name: troute}
-        : troute
-
-      if (! route.name) {
+      if (!route.name) {
         continue
       }
 
-      const parsed_route= {
+      const parsed_route = {
         name: route.name,
         url: route?.url || route.name,
-        mode: route?.mode || 'rw',
+        mode: route?.mode || "rw",
 
         bodyField: route?.bodyField || comm_bodyField,
-        useUserFields: merge.all([
-          DEFAULT_USE_USER_FIELDS,
-          route?.useUserFields || {}
-        ]),
-        auth: merge.all([
-          comm_auth,
-          route?.auth  || {}
-        ]),
+        useUserFields: merge.all([DEFAULT_USE_USER_FIELDS, route?.useUserFields || {}]),
+        auth: merge.all([comm_auth, route?.auth || {}]),
 
         before: route?.before || comm_before,
         after: route?.after || comm_after
       }
       parsed_routes.push(parsed_route)
     }
-    
-    if (parsed_routes.length>0) {
-      output.push( {
-        prefix: crud?.prefix || '',
+
+    if (parsed_routes.length > 0) {
+      output.push({
+        prefix: crud?.prefix || "",
         routes: parsed_routes
-      } )
+      })
     }
-
   })
 
   return output
-
 }
 
-
 export default getCrudConfig

package/src/middleware/routes/router/defaults.mjs

@@ -1,29 +1,16 @@
-const DEFAULT_BEFORE_CALLBACK = async (ctx) => {
-  return true
-}
-
-const DEFAULT_AFTER_CALLBACK = async (ctx, result) => {
-  return result
-}
-
 const DEFAULT_AUTH_USER = {
-  require: false,     // true / false / 'read-only'
-  action: 'redirect', // 'error'
-  redirect_url: '/',
+  require: false, // true / false / 'read-only'
+  action: "redirect", // 'error'
+  redirect_url: "/",
   error_code: 401
 }
 
 const DEFAULT_USE_USER_FIELDS = {
   use: false,
   fieldNames: {
-    created_by: 'created_by', 
-    last_update_by: 'last_update_by'
+    created_by: "created_by",
+    last_update_by: "last_update_by"
   }
 }
 
-export {
-  DEFAULT_AUTH_USER,
-  DEFAULT_USE_USER_FIELDS,
-  DEFAULT_BEFORE_CALLBACK,
-  DEFAULT_AFTER_CALLBACK
-}
+export { DEFAULT_AUTH_USER, DEFAULT_USE_USER_FIELDS }

package/src/middleware/routes/router/index.mjs

@@ -1,28 +1,27 @@
-import Router    from '@koa/router'
-import getCrudConfig from './crud/getCrudConfig.mjs'
-import attachCrudRoutes from './crud/attachCrudRoutes.mjs'
-import getQueriesConfig from './queries/getQueriesConfig.mjs'
-import attachQueriesRoutes from './queries/attachQueriesRoutes.mjs'
-
+import Router from "@koa/router"
+import attachCrudRoutes from "./crud/attachCrudRoutes.mjs"
+import getCrudConfig from "./crud/getCrudConfig.mjs"
+import attachQueriesRoutes from "./queries/attachQueriesRoutes.mjs"
+import getQueriesConfig from "./queries/getQueriesConfig.mjs"
 
 function init_router(app, routes) {
   const logger = app.context.miolo.logger
 
   // Init the Koa Router
   const router = new Router()
-  
+
   try {
     // Parse routes
-    const crudConfigs= getCrudConfig(routes)
-    const queriesConfigs= getQueriesConfig(routes)
-    
+    const crudConfigs = getCrudConfig(routes)
+    const queriesConfigs = getQueriesConfig(routes)
+
     // check routes
-    const crudConfigsOk= crudConfigs.length > 0
-    const queriesConfigsOk= queriesConfigs.length > 0
+    const crudConfigsOk = crudConfigs.length > 0
+    const queriesConfigsOk = queriesConfigs.length > 0
 
-    if ( (!crudConfigsOk) && (!queriesConfigsOk)) {
+    if (!crudConfigsOk && !queriesConfigsOk) {
       throw "[router] Could not get any route from the passed <routes> param"
-    }  
+    }
 
     // attach CRUD routes
     if (crudConfigsOk) {
@@ -33,17 +32,14 @@ function init_router(app, routes) {
     if (queriesConfigsOk) {
       attachQueriesRoutes(router, queriesConfigs, logger)
     }
-  } catch(e) {
-    logger.error('[router] Error initing the router.')
-    logger.error('[router] routes:')
+  } catch (e) {
+    logger.error("[router] Error initing the router.")
+    logger.error("[router] routes:")
     logger.error(routes)
     logger.error(e)
-    
   }
 
   app.use(router.routes())
 }
 
-
-
-export {init_router}
+export { init_router }

package/src/middleware/routes/router/queries/attachQueriesRoutes.mjs

@@ -1,102 +1,279 @@
-import {query_string_to_json} from '../utils.mjs'
+import Joi from "joi"
+import { ensure_response_is_ok_data, query_string_to_json } from "../utils.mjs"
 
 function attachQueriesRoutes(router, queriesConfigs, logger) {
+  queriesConfigs.forEach((queriesConfig) => {
+    const prefix = queriesConfig.prefix
 
-  queriesConfigs.map((queriesConfig) => {
-      
-    const prefix= queriesConfig.prefix
-
-    queriesConfig.routes.map(route => {
-      
-      let url = (!prefix)
-        ? `/${route.url}`
-        : `/${prefix}/${route.url}`
-      while (url.indexOf('//')>=0) {
-        url= url.replace(/\/\//g, "/")
+    queriesConfig.routes.forEach((route) => {
+      let url = !prefix ? `/${route.url}` : `/${prefix}/${route.url}`
+      while (url.indexOf("//") >= 0) {
+        url = url.replace(/\/\//g, "/")
       }
 
       const routeAuth = route.auth
-      const checkAuth= (routeAuth.require===true) || (routeAuth.require==='read-only' && route.method==='POST')
-  
-      logger.debug(`[router] Routing ${route.callback?.name || 'callback'} to ${route.method} ${url}${checkAuth ? ' (auth)' : ''}`)
+      const checkAuth =
+        routeAuth.require === true || (routeAuth.require === "read-only" && route.method === "POST")
+
+      logger.debug(
+        `[router] Routing ${route.callback?.name || "callback"} to ${route.method} ${url}${checkAuth ? " (auth)" : ""}`
+      )
 
       const _route_auth_callback = async (ctx) => {
-        
         if (checkAuth) {
-          const authenticated= ctx?.session?.authenticated === true
+          const authenticated = ctx?.session?.authenticated === true
           if (!authenticated) {
-            if (routeAuth.action=='error') {
+            if (routeAuth.action === "error") {
               ctx.miolo.logger.error(`Unauthorized access. Throwing error ${routeAuth.error_code}`)
-              ctx.throw(
-                routeAuth.error_code,
-                'Unauthorized',
-                {}
-              )
-            } else if (routeAuth.action=='redirect') {
+              ctx.throw(routeAuth.error_code, new Error("Unauthorized"), {})
+            } else if (routeAuth.action === "redirect") {
               ctx.miolo.logger.warn(`Unauthorized access. Redirecting to ${routeAuth.redirect_url}`)
               ctx.redirect(routeAuth.redirect_url)
             } else {
               ctx.miolo.logger.error(`Route path ${route.url} specified auth but no action`)
-              ctx.body= {}
             }
           }
 
           return authenticated
         }
-    
+
         return true
       }
 
       const _route_callback = async (ctx) => {
-        let result = {}
         try {
           try {
-            if ((route.method == 'GET') && (!ctx.request?.body)) {
-              if (ctx.request.url.indexOf('?')>0) {
-                const fields= query_string_to_json(ctx.request.url)
+            if (route.method === "GET" && !ctx.request?.body) {
+              if (ctx.request.url.indexOf("?") > 0) {
+                const fields = query_string_to_json(ctx.request.url)
                 if (fields) {
-                  ctx.request.body= fields
+                  ctx.request.body = fields
                 }
               }
             }
-          } catch(e) {
-            ctx.miolo.logger.error(`[router] Error while trying to qet query params for ${ctx.request.url}`)
+          } catch (error) {
+            ctx.miolo.logger.error(
+              `[router] Error while trying to qet query params for ${ctx.request.url}: ${error?.message || "?"}`
+            )
           }
 
           const authenticated = await _route_auth_callback(ctx)
-          if (! authenticated) {
+          if (!authenticated) {
+            ctx.body = {
+              ok: false,
+              error: "Not authorized"
+            }
             return
           }
-          
-          let goon= true
+
+          let goon = true
           if (route?.before) {
-            goon= await route.before(ctx)
+            if (Array.isArray(route.before)) {
+              for (const before of route.before) {
+                goon = await before(ctx)
+                if (!goon) {
+                  break
+                }
+              }
+            } else {
+              goon = await route.before(ctx)
+            }
+
+            if (!goon) {
+              ctx.body = {
+                ok: false,
+                error: `Route was aborted by a <before> callback (${route.before?.name})`
+              }
+              return
+            }
           }
 
-          if (! goon) {
-            return
+          const inputSchema = route?.schema?.input
+
+          if (inputSchema) {
+            // Check schema is actually a schema
+            if (!Joi.isSchema(inputSchema)) {
+              ctx.miolo.logger.error(
+                `[router] Expecting input schema at ${url} but something else was found (${typeof inputSchema})`
+              )
+              ctx.body = {
+                ok: false,
+                error: "Invalid input schema"
+              }
+              return
+            }
+
+            try {
+              const v = inputSchema.validate(ctx.request.body)
+
+              if (v?.error) {
+                ctx.miolo.logger.warn(
+                  `[router] Input schema invalidated data for ${url}: ${v.error}\n${v.error.annotate(true)}`
+                )
+                ctx.body = {
+                  ok: false,
+                  error: v.error.toString()
+                }
+                return
+              } else if (v?.value) {
+                ctx.miolo.logger.silly(
+                  `[router] Input schema validated data for ${url} successfully`
+                )
+                ctx.request.body = v.value
+              } else {
+                const description = inputSchema.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) {
+                  ctx.miolo.logger.silly(
+                    `[router] Input schema allowed null param to ${url} successfully`
+                  )
+                  ctx.request.body = v.value
+                } else {
+                  ctx.miolo.logger.warn(
+                    `[router] Input schema returned unknown result for ${url}: ${JSON.stringify(v)}. Let's ignore it.`
+                  )
+                }
+              }
+            } catch (error) {
+              ctx.miolo.logger.error(
+                `[router] Error validating input schema at ${url}: ${error?.message || error}`
+              )
+              ctx.body = {
+                ok: false,
+                error: error?.message || error
+              }
+              return
+            }
+          }
+
+          const result = await route.callback(ctx, ctx.request.body)
+
+          if (!route.keep_body) {
+            if (ctx.body !== undefined) {
+              ctx.body = ensure_response_is_ok_data(ctx, ctx.body)
+            } else {
+              ctx.body = ensure_response_is_ok_data(ctx, result)
+            }
           }
-      
-          result= await route.callback(ctx)
-          
+
           if (route?.after) {
-            result= await route.after(ctx, result)
+            if (Array.isArray(route.after)) {
+              for (const after of route.after) {
+                const result = await after(ctx, ctx.body)
+                ctx.body = ensure_response_is_ok_data(ctx, result)
+              }
+            } else {
+              const result = await route.after(ctx, ctx.body)
+              ctx.body = ensure_response_is_ok_data(ctx, result)
+            }
+          }
+
+          // If body has no ok and read data, do not validate it
+          if (ctx.body?.ok !== true || !ctx.body?.data) {
+            return
+          }
+
+          const outputSchema = route?.schema?.output
+
+          if (outputSchema) {
+            // Check schema is actually a schema
+            if (!Joi.isSchema(outputSchema)) {
+              ctx.miolo.logger.error(
+                `[router] Expecting output schema at ${url} but something else was found (${typeof outputSchema})`
+              )
+              ctx.body = {
+                ok: false,
+                error: "Invalid output schema"
+              }
+              return
+            }
+
+            // perform validation over the result
+            let v
+            try {
+              v = outputSchema.validate(ctx.body.data, { stripUnknown: true })
+            } catch (uerror) {
+              const error = `Unexpected error validating output data for ${url}: ${uerror?.message || uerror}`
+              ctx.miolo.logger.warn(`[router] ${error}`)
+              ctx.body = {
+                ok: false,
+                error: error
+              }
+              return
+            }
+
+            // raise validation errors
+            if (v?.error) {
+              ctx.miolo.logger.warn(
+                `[router] Output schema invalidated data for ${url}: ${v.error}\n${v.error.annotate(true)}`
+              )
+              ctx.body = {
+                ok: false,
+                error: v.error.toString()
+              }
+              return
+            }
+
+            if (v?.value) {
+              const diff = diffObjs(ctx.body.data, v.value)
+              if (diff) {
+                ctx.miolo.logger.debug(`[router] Output schema has removed ${diff} for URL ${url}`)
+              }
+
+              ctx.miolo.logger.silly(
+                `[router] Output schema validated data for ${url} successfully`
+              )
+              ctx.body.data = v.value
+            }
+
+            // check parsed value is ok
+            if (!v?.value) {
+              const description = outputSchema.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) {
+                const error = `Output schema returned unknown result for ${fn.name}: ${JSON.stringify(v)}`
+                ctx.miolo.logger.silly(`[router][${fn.name}] ${error}`)
+                ctx.body = {
+                  ok: false,
+                  error: error
+                }
+                return
+              }
+            }
           }
-        } catch(error) {
-          ctx.miolo.logger.error(`[router] Unexpected error on Query ${route.callback?.name} at ${url}`)
+        } catch (error) {
+          ctx.miolo.logger.error(
+            `[router] Unexpected error on Query ${route.callback?.name} at ${url}`
+          )
           ctx.miolo.logger.error(error)
+          ctx.body = {
+            ok: false,
+            error: error?.message || error
+          }
         }
-
-        return result
       }
 
       const router_method = route.method.toLowerCase()
 
       router[router_method](url, (ctx) => _route_callback(ctx, route))
-
     })
-
   })
 }
 
-export default attachQueriesRoutes
+export default attachQueriesRoutes