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

package/src/middleware/http/catcher.mjs

@@ -3,17 +3,92 @@
  * @param ctx
  */
 
-import http from 'http'
+// import http from 'http'
+import statuses from 'statuses'
+import util from 'node:util'
+
 const _ONLY_WARN= [401, 403]
 
 function init_catcher_middleware(app) {
   const logger= app.context.miolo.logger
   
   async function catcher_middleware(err) {
+    // don't do anything if there is no error.
+    // this allows you to pass `this.onerror`
+    // to node-style callbacks.
+    if (err == null) return
+    
+    // Ignore this error 
+    // Appearing since Koa 3.1 + koa-static 6.x + koa-send 7.x
+    if (err.code === 'ERR_STREAM_PREMATURE_CLOSE') return
+
+
+    // When dealing with cross-globals a normal `instanceof` check doesn't work properly.
+    // See https://github.com/koajs/koa/issues/1466
+    // We can probably remove it once jest fixes https://github.com/facebook/jest/issues/2549.
+    const isNativeError =
+      Object.prototype.toString.call(err) === '[object Error]' ||
+      err instanceof Error
+    if (!isNativeError) err = new Error(util.format('non-error thrown: %j', err))
+
+    let headerSent = false
+    if (this.headerSent || !this.writable) {
+      headerSent = err.headerSent = true
+    }
+
+    // delegate
+    this.app.emit('error', err, this)
+
+    
+    let statusCode = err.status || err.statusCode
+    // default to 500
+    if (typeof statusCode !== 'number' || !statuses.message[statusCode]) statusCode = 500    
+
+    // Log the error depending on the status
+    const ip = this.headers["x-real-ip"] || this.headers["x-orig-ip"] || this.ip || '127.0.0.1'
+    if ((_ONLY_WARN.indexOf(statusCode)>=0) || (err.message.indexOf('Premature close')>=0)) {
+      logger.warn(`[${ip}] ${this.method} ${this.url} - ${statusCode}: ${err.message}`)
+    } else {
+      logger.error(`[${ip}] ${this.method} ${this.url} - ${statusCode}: ${err.message}`)
+    }
+
+    // nothing we can do here other
+    // than delegate to the app-level
+    // handler and log.
+    if (headerSent) {
+      return
+    }
+
+    const { res } = this
+
+    // first unset all headers
+    /* istanbul ignore else */
+    if (typeof res.getHeaderNames === 'function') {
+      res.getHeaderNames().forEach(name => res.removeHeader(name))
+    } else {
+      res._headers = {} // Node < 7.7
+    }
+
+    // then set those specified
+    this.set(err.headers)
+
+    // force text/plain
+    this.type = 'text'
+
+
+    // respond
+    const code = statuses.message[statusCode]
+    const msg = err.expose ? err.message : code
+    this.status = err.status = statusCode
+    this.length = Buffer.byteLength(msg)
+    res.end(msg)
+    
+    /*
     if (!err) return
 
     // wrap non-error object
-    if (!(err instanceof Error)) {
+    const isNativeError = (Object.prototype.toString.call(err) === '[object Error]') || (err instanceof Error)
+    if (!isNativeError) {
       let errMsg = err;
       if (typeof err === 'object') {
         try {
@@ -73,6 +148,7 @@ function init_catcher_middleware(app) {
     this.body = JSON.stringify(this.body || '', null, 2)
     this.length = Buffer.byteLength(this.body)
     this.res.end(this.body)
+    */
   }
 
   app.context.onerror = catcher_middleware

package/src/middleware/http/catcher.old.mjs

@@ -0,0 +1,82 @@
+/**
+ * Middleware for catching errors thrown in routes
+ * @param ctx
+ */
+
+import http from 'http'
+const _ONLY_WARN= [401, 403]
+
+function init_catcher_middleware(app) {
+  const logger= app.context.miolo.logger
+  
+  async function catcher_middleware(err) {
+    if (!err) return
+
+    // wrap non-error object
+    const isNativeError = (Object.prototype.toString.call(err) === '[object Error]') || (err instanceof Error)
+    if (!isNativeError) {
+      let errMsg = err;
+      if (typeof err === 'object') {
+        try {
+          errMsg = JSON.stringify(err);
+          // eslint-disable-next-line no-empty
+        } catch (e) {}
+      }
+      const newError = new Error('non-error thrown: ' + errMsg);
+      // err maybe an object, try to copy the name, message and stack to the new error instance
+      if (err) {
+        if (err.name) newError.name = err.name;
+        if (err.message) newError.message = err.message;
+        if (err.stack) newError.stack = err.stack;
+        if (err.status) newError.status = err.status;
+        if (err.headers) newError.headers = err.headers;
+      }
+      err = newError;
+    }
+    
+    const headerSent = this.headerSent || !this.writable;
+    if (headerSent) err.headerSent = true;
+    
+    // delegate
+    this.app.emit('error', err, this);    
+
+    // ENOENT support
+    if (err.code === 'ENOENT') err.status = 404;
+
+    // Get HTML status code
+    let status = err.status || 400
+    const type = this.accepts(['text', 'json', 'html'])
+    if (!type) {
+      status = 406
+      err.message = 'Unsupported type'
+    } else if (typeof err.status !== 'number' || !http.STATUS_CODES[err.status]) {
+      err.status = 500
+    }
+    this.status = status
+  
+
+    // Log the error depending on the status
+    const ip = this.headers["x-real-ip"] || this.headers["x-orig-ip"] || this.ip || '127.0.0.1'
+    if (_ONLY_WARN.indexOf(status)>=0) {
+      logger.warn(`[${ip}] ${this.method} ${this.url} - ${status}: ${err.message}`)
+    } else {
+      logger.error(err)
+    }
+
+    // Nothing we can do here other than delegate to the app-level handler and log.
+    if (err.headerSent ) {
+      logger.warn('headers were already sent, returning early')
+      return
+    }
+
+    // Prepare response a bit
+    this.type = 'json'
+    this.body = JSON.stringify(this.body || '', null, 2)
+    this.length = Buffer.byteLength(this.body)
+    this.res.end(this.body)
+  }
+
+  app.context.onerror = catcher_middleware
+}
+
+export {init_catcher_middleware}

package/src/middleware/http/custom_blacklist.mjs

@@ -13,5 +13,7 @@ export const CUSTOM_BLACKLIST_IPS= [
   '198.12.222.107', // GoDaddy.com, LLC (GODAD)
   '212.128.118.10', // RIPE Network Coordination Centre (RIPE)
   '103.218.240.46', // Asia Pacific Network Information Centre (APNIC)
-  '45.15.167.150'   // ??
+  '45.15.167.150',  // ??
+  '165.227.173.41', // Frankfurt am Main, DE
+  '147.135.220.53', // 
 ]

package/src/middleware/routes/catch_js_error.mjs

@@ -1,12 +1,24 @@
 import { blue, red, yellow } from 'tinguir'
 import Router    from '@koa/router'
 
+const ERRORS_AS_WARNINGS = [
+  'Minified React error'
+]
+
 function init_route_catch_js_error(app, route) {
   
   async function catch_js_error(ctx) {
-    const { error, warning, path, agent } = ctx.request.body
+    let { error, warning, path, agent } = ctx.request.body
     const logger = ctx.miolo.logger
 
+    if (error) {
+      ERRORS_AS_WARNINGS.map(e => {
+        if (error.msg.indexOf(e) >= 0) {
+         warning = error 
+        }
+      })
+    }
+
     if (warning) {
       const msg= 
       `${yellow('[JS Warning]')} on ${blue(path)}: ${JSON.stringify(warning.msg)}\n` +
@@ -28,7 +40,7 @@ function init_route_catch_js_error(app, route) {
       logger.error(msg)
     }
 
-    ctx.body = {result: 1}
+    ctx.body = {ok: true, data: 1}
   }
 
   const catch_js_error_router = new Router()

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

@@ -11,9 +11,10 @@ function attachCrudRoutes(router, crudConfigs, logger) {
 
       const _pack_body_field = (data) => {
         if (route.bodyField == undefined) {
-          return data
+          return {data}
         }
         return {
+          bodyField: route.bodyField,
           [route.bodyField]: data
         }
       }
@@ -32,15 +33,22 @@ function attachCrudRoutes(router, crudConfigs, logger) {
               ctx.miolo.logger.error(`[router] Unauthorized access. Throwing error ${auth.error_code}`)
               ctx.throw(
                 auth.error_code,
-                'Unauthorized',
+                new Error('Unauthorized'),
                 {}
               )
             } else if (auth.action=='redirect') {
               ctx.miolo.logger.warn(`[router] Unauthorized access. Redirecting to ${auth.redirect_url}`)
+              ctx.body= {
+                ok: false,
+                error: 'Unathorized'
+              }
               ctx.redirect(auth.redirect_url)
             } else {
               ctx.miolo.logger.error(`[router] Crud path ${route.url} specified auth but no action`)
-              ctx.body= {}
+              ctx.body= {
+                ok: false,
+                error: 'Unathorized'
+              }
             }
           }
           return authenticated
@@ -57,12 +65,15 @@ function attachCrudRoutes(router, crudConfigs, logger) {
           throw new Error(`[router] Could not get model for ${route.name}`)
         }
 
-        let result = {}
+        let data = {}
         try {
           const authenticated = await _crud_auth_callback(ctx, op)
 
           if (! authenticated) {
-            ctx.body= {}
+            ctx.body= {
+              ok: false,
+              error: 'Unathorized'
+            }
             return
           }
           
@@ -72,7 +83,10 @@ function attachCrudRoutes(router, crudConfigs, logger) {
           }
 
           if (! goon) {
-            ctx.body= {}
+            ctx.body= {
+              ok: false,
+              error: 'Not allowd'
+            }
             return
           }
 
@@ -87,19 +101,17 @@ function attachCrudRoutes(router, crudConfigs, logger) {
             fieldNames,
           }
           
-          result= await callback(model, uinfo)
+          data= await callback(model, uinfo)
           
           if (route?.after) {
-            result= await route.after(ctx, result)
+            data= await route.after(ctx, data)
           }
         } catch(error) {
           ctx.miolo.logger.error(`[router] Unexpected error on CRUD ${route.name}-${op}`)
           ctx.miolo.logger.error(error)
         }
-
-        result= _pack_body_field(result)
-
-        ctx.body= result
+       
+        ctx.body= {ok: true, ..._pack_body_field(data)}
       }
 
       const route_read = async (ctx) => {

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

@@ -3,8 +3,6 @@ import merge from 'deepmerge'
 import {
   DEFAULT_AUTH_USER,
   DEFAULT_USE_USER_FIELDS,
-  DEFAULT_BEFORE_CALLBACK,
-  DEFAULT_AFTER_CALLBACK
 } from "../defaults.mjs"
 
 /**
@@ -14,7 +12,7 @@ import {
     auth,
     bodyField,
     before: (ctx) => {return goon/!goon},
-    after : (ctx, result) => {return result},
+    after : (ctx, data) => {return data},
     
     routes: an array of tables config, where each config can be:
       - a simple string with the table name
@@ -36,7 +34,7 @@ import {
           auth,
           bodyField,
           before: (ctx) => {return goon/!goon},
-          after : (ctx, result) => {return result},
+          after : (ctx, data) => {return data},
     
         }      
   }]
@@ -69,8 +67,8 @@ const getCrudConfig = (config) => {
     }
     
     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([

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

@@ -1,11 +1,3 @@
-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'
@@ -23,7 +15,5 @@ const DEFAULT_USE_USER_FIELDS = {
 
 export {
   DEFAULT_AUTH_USER,
-  DEFAULT_USE_USER_FIELDS,
-  DEFAULT_BEFORE_CALLBACK,
-  DEFAULT_AFTER_CALLBACK
+  DEFAULT_USE_USER_FIELDS
 }

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

@@ -4,7 +4,6 @@ import attachCrudRoutes from './crud/attachCrudRoutes.mjs'
 import getQueriesConfig from './queries/getQueriesConfig.mjs'
 import attachQueriesRoutes from './queries/attachQueriesRoutes.mjs'
 
-
 function init_router(app, routes) {
   const logger = app.context.miolo.logger
 

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

@@ -1,4 +1,7 @@
-import {query_string_to_json} from '../utils.mjs'
+import Joi from 'joi'
+import {
+  query_string_to_json,
+  ensure_response_is_ok_data} from '../utils.mjs'
 
 function attachQueriesRoutes(router, queriesConfigs, logger) {
 
@@ -21,7 +24,6 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
       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
           if (!authenticated) {
@@ -29,7 +31,7 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
               ctx.miolo.logger.error(`Unauthorized access. Throwing error ${routeAuth.error_code}`)
               ctx.throw(
                 routeAuth.error_code,
-                'Unauthorized',
+                new Error('Unauthorized'),
                 {}
               )
             } else if (routeAuth.action=='redirect') {
@@ -37,7 +39,6 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
               ctx.redirect(routeAuth.redirect_url)
             } else {
               ctx.miolo.logger.error(`Route path ${route.url} specified auth but no action`)
-              ctx.body= {}
             }
           }
 
@@ -48,7 +49,6 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
       }
 
       const _route_callback = async (ctx) => {
-        let result = {}
         try {
           try {
             if ((route.method == 'GET') && (!ctx.request?.body)) {
@@ -59,35 +59,92 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
                 }
               }
             }
-          } 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) {
+            ctx.body= {
+              ok: false,
+              error: 'Not authorized'
+            }
             return
           }
           
           let goon= true
           if (route?.before) {
             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
+          if (route?.schema) {
+            // Check schema is actually a schema
+            if (! Joi.isSchema(route.schema)) {
+              ctx.miolo.logger.error(`[router] Expecting schema at ${url} but something else was found (${typeof route.schema})`)
+              ctx.body = {
+                ok: false,
+                error: 'Invalid schema'
+              }
+              return
+            }
+            
+            try {
+              const v = route.schema.validate(ctx.request.body)
+              
+              if (v?.error) {
+                ctx.miolo.logger.warn(`[router] 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] Schema validated data for ${url} successfully`)
+                ctx.request.body = v.value
+              } else {
+                ctx.miolo.logger.warn(`[router] Schema returned unknown result for ${url}: ${JSON.stringify(v)}. Let's ignore it.`)
+              }
+              
+            } catch(error) {
+              ctx.miolo.logger.error(`[router] Error validating schema at ${url}: ${error?.message || error}`)
+              ctx.body = {
+                ok: false,
+                error: error?.message || error
+              }
+              return
+            }
           }
       
-          result= await route.callback(ctx)
+          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)
+            }
+          }
           
           if (route?.after) {
-            result= await route.after(ctx, result)
+            const result = await route.after(ctx, ctx.body)
+            ctx.body = ensure_response_is_ok_data(ctx, result)
           }
         } 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()

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

@@ -1,11 +1,7 @@
 import merge from 'deepmerge'
-
 import {
-  DEFAULT_AUTH_USER,
-  DEFAULT_BEFORE_CALLBACK,
-  DEFAULT_AFTER_CALLBACK
+  DEFAULT_AUTH_USER
 } from "../defaults.mjs"
-import { make_endpoint_from_fn } from '../utils.mjs'
 
 /**
   {
@@ -13,7 +9,7 @@ import { make_endpoint_from_fn } from '../utils.mjs'
 
     auth,
     before: (ctx) => {return goon/!goon},
-    after : (ctx, result) => {return result},
+    after : (ctx, data) => {return data},
     
 
     routes: [
@@ -21,13 +17,20 @@ import { make_endpoint_from_fn } from '../utils.mjs'
       {
         url: '/crud/todos/fake',
         method: 'GET', // 'POST'
-        callback: async (ctx) => { ctx.body = result } ,  
-          // or
-        callback_fn: async (miolo, params) => { return result } , 
-
+        callback: async (ctx, params) => { 
+          return {ok: true/false, data|error} 
+          // or:
+          //  return <anything>
+          //  and milo will wrap into {ok: true, data: <anything>}
+          // or by yourself:
+          // ctx.body = {ok: true/false, data|error}
+          //  (you may want {keep_body: true})
+        } ,  
         auth,
-        before: (ctx) => {return goon/!goon},
-        after : (ctx, result) => {return result},
+        before:  async (ctx) => { return true/false },
+        after :  async (ctx, data) => { return data },
+        schema: a Joi schema,
+        keep_body: false by default. If true, miolo wont wnsure ctx.body after callback.
       }
     ]
   }   
@@ -61,8 +64,8 @@ const getQueriesConfig = (config) => {
       return
     }
     
-    const comm_before = instance?.before || config?.before || DEFAULT_BEFORE_CALLBACK
-    const comm_after = instance?.after || config?.after || DEFAULT_AFTER_CALLBACK
+    const comm_before = instance?.before || config?.before
+    const comm_after = instance?.after || config?.after
 
     const comm_auth= merge.all([
       DEFAULT_AUTH_USER,
@@ -77,12 +80,7 @@ const getQueriesConfig = (config) => {
         continue
       }
       
-      let cb=undefined
-      if ((! route.callback) && (! route.callback_fn)) {
-        continue
-      } else {
-        cb = route.callback || make_endpoint_from_fn(route.callback_fn)
-      }
+      let cb=route?.callback 
 
       const parsed_route= {
         url: route.url,
@@ -95,7 +93,9 @@ const getQueriesConfig = (config) => {
         ]),
 
         before: route?.before || comm_before,
-        after: route?.after || comm_after
+        after: route?.after || comm_after,
+        schema: route?.schema,
+        keep_body: route?.keep_body === true
       }
 
       parsed_routes.push(parsed_route)