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

package/src/middleware/http/request.mjs

@@ -1,21 +1,25 @@
-import { performance } from 'perf_hooks'
-import { cyan, green, yellow, red, magenta, cyan_light } from 'tinguir'
+import { performance } from "node:perf_hooks"
+import { cyan, cyan_light, green, magenta, red, yellow } from "tinguir"
 
-import { geoip_localize_ip } from '../../engines/geoip/index.mjs'
+import { geoip_localize_ip } from "../../engines/geoip/index.mjs"
 
-let REQUEST_COUNTER= {
+const REQUEST_COUNTER = {
   total: 0
 }
 
-function _validate_ip(ipaddress) {  
-  if (/^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ipaddress)) {  
+function _validate_ip(ipaddress) {
+  if (
+    /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(
+      ipaddress
+    )
+  ) {
     return true
   }
   return false
 }
 
 const _get_ip = (ctx) => {
-  const chances = [ctx.headers["x-real-ip"], ctx.headers["x-orig-ip"], ctx.ip, '127.0.0.1']
+  const chances = [ctx.headers["x-real-ip"], ctx.headers["x-orig-ip"], ctx.ip, "127.0.0.1"]
   for (const ch of chances) {
     if (_validate_ip(ch)) {
       return ch
@@ -28,12 +32,12 @@ const _get_ip = (ctx) => {
  */
 
 function init_request_middleware(app, config) {
+  const _def_on_begin = async (_ctx, _times) => {
+    return {}
+  }
+  const _def_on_done = async (_ctx, _begin_result, _times) => {}
 
-  /* eslint-disable no-unused-vars */
-  const _def_on_begin = async (ctx, times) => { return {} }
-  const _def_on_done  = async (ctx, begin_result, times) => { }
-
-  let reqConfig = {
+  const reqConfig = {
     lazy: config?.lazy || 1,
     slow: config?.slow || 2,
     onStart: config?.onStart || _def_on_begin,
@@ -43,18 +47,17 @@ function init_request_middleware(app, config) {
     }
   }
 
- 
   async function request_middleware(ctx, next) {
     const logger = ctx.miolo.logger
     const ip = _get_ip(ctx)
     const started = performance.now()
-    
+
     // Keep request counters
-    REQUEST_COUNTER.total+= 1
+    REQUEST_COUNTER.total += 1
     REQUEST_COUNTER[ip] = (REQUEST_COUNTER[ip] || 0) + 1
-    
+
     // Attach some info to request
-    ctx.requestId= REQUEST_COUNTER.total
+    ctx.requestId = REQUEST_COUNTER.total
     ctx.request.ip = ip
 
     // If wanted, geo localize ip
@@ -66,81 +69,73 @@ function init_request_middleware(app, config) {
     ctx.request.geoip = geo_info
 
     // Log something
-    const clurl = ctx.request.url.indexOf('?')>=0
-      ? ctx.request.url.substr(0, ctx.request.url.indexOf('?'))
-      : ctx.request.url
-    const geo_string = geo_enabled 
-    ? geo_info?.local === true
-      ? ''
-      : geo_info?.country 
-        ? geo_info?.city
-          ? ` (${geo_info?.city}, ${geo_info.country})`
-          : ` (${geo_info.country})`
-        : ''
-      : ''
+    const clurl =
+      ctx.request.url.indexOf("?") >= 0
+        ? ctx.request.url.substr(0, ctx.request.url.indexOf("?"))
+        : ctx.request.url
+    const geo_string = geo_enabled
+      ? geo_info?.local === true
+        ? ""
+        : geo_info?.country
+          ? geo_info?.city
+            ? ` (${geo_info?.city}, ${geo_info.country})`
+            : ` (${geo_info.country})`
+          : ""
+      : ""
     const sreq = `${magenta(ip)}${geo_string} ${cyan(ctx.request.method)} ${cyan(clurl)} [${cyan_light(REQUEST_COUNTER[ip])}/${cyan_light(ctx.requestId)}]`
-    const sbody= ctx.request.body!=undefined ? JSON.stringify(ctx.request.body) : ''
-    
+    const sbody = ctx.request.body !== undefined ? JSON.stringify(ctx.request.body) : ""
+
     logger.info(`${sreq} - START`)
     logger.debug(`${sreq} - Body: ${sbody}`)
 
-    const begin_result = await reqConfig.onStart(ctx, {started, description: 'pending'})
+    const begin_result = await reqConfig.onStart(ctx, { started, description: "pending" })
 
-    await next()    
+    await next()
 
     const user = ctx?.session?.user
-    let uid_desc= ''
-    if (user != undefined) {
+    let uid_desc = ""
+    if (user !== undefined && user !== null) {
       if (user?.id) {
-        uid_desc= ` - uid ${user?.id}`
+        uid_desc = ` - uid ${user?.id}`
       } else if (user?.token) {
-        uid_desc= ` - token ${user?.token}`
+        uid_desc = ` - token ${user?.token}`
       }
     }
     const status = ctx.response.status
-    let ststr= status
+    let ststr = status
     let stcolor
-    if (status==200) {
-      stcolor= green
-    } else if (status>200 && status<=299) {
-      stcolor= yellow
+    if (status === 200) {
+      stcolor = green
+    } else if (status > 200 && status <= 299) {
+      stcolor = yellow
       if (ctx.response.redirected && ctx.response.url) {
-        ststr+= ` -> ${ctx.response.url}`
-
+        ststr += ` -> ${ctx.response.url}`
       }
     } else {
-      stcolor= red
+      stcolor = red
     }
     const stdesc = `[${stcolor(ststr)}]`
 
-    const elapsed = parseFloat( (performance.now() - started) / 1000.0 ).toFixed(2)
-
-    const tcolor= elapsed < reqConfig.lazy
-                  ? green
-                  : elapsed < reqConfig.slow
-                    ? yellow
-                    : red 
-
-    const tname= elapsed < reqConfig.lazy
-                  ? 'Ok'
-                  : elapsed < reqConfig.slow
-                    ? 'lazy'
-                    : 'slow' 
-    
-    const ssession= ctx.session!=undefined ? JSON.stringify(ctx.session) : ''
+    const elapsed = parseFloat((performance.now() - started) / 1000.0).toFixed(2)
+
+    const tcolor = elapsed < reqConfig.lazy ? green : elapsed < reqConfig.slow ? yellow : red
+
+    const tname = elapsed < reqConfig.lazy ? "Ok" : elapsed < reqConfig.slow ? "lazy" : "slow"
+
+    const ssession = ctx.session !== undefined ? JSON.stringify(ctx.session) : ""
     logger.debug(`${sreq} - Session: ${ssession.slice(0, 150)}...`)
     logger.silly(`${sreq} - Session: ${ssession}`)
 
-    const rbody= ctx.body!=undefined ? JSON.stringify(ctx.body) : ''
+    const rbody = ctx.body !== undefined ? JSON.stringify(ctx.body) : ""
     logger.debug(`${sreq} - Response: ${rbody.slice(0, 150)}...`)
     logger.silly(`${sreq} - Response: ${rbody}`)
 
-    await reqConfig.onDone(ctx, begin_result, {started, elapsed, description: tname})
-    
+    await reqConfig.onDone(ctx, begin_result, { started, elapsed, description: tname })
+
     logger.info(`${sreq} - DONE ${stdesc}${uid_desc} (${tcolor(tname)}: ${tcolor(elapsed)})`)
   }
- 
+
   app.use(request_middleware)
 }
 
-export {init_request_middleware}
+export { init_request_middleware }

package/src/middleware/routes/catch_js_error.mjs

@@ -1,41 +1,48 @@
-import { blue, red, yellow } from 'tinguir'
-import Router    from '@koa/router'
+import Router from "@koa/router"
+import { blue, red, yellow } from "tinguir"
+
+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.forEach((e) => {
+        if (error.msg.indexOf(e) >= 0) {
+          warning = error
+        }
+      })
+    }
+
     if (warning) {
-      const msg= 
-      `${yellow('[JS Warning]')} on ${blue(path)}: ${JSON.stringify(warning.msg)}\n` +
-      `${yellow('[JS Warning]')} File  => ${warning.file}\n` +
-      `${yellow('[JS Warning]')} Line  => ${warning.line}\n` + 
-      `${yellow('[JS Warning]')} Col   => ${warning.col}\n` + 
-      `${yellow('[JS Warning]')} Error => ${JSON.stringify(warning.error)}\n` + 
-      `${yellow('[JS Warning]')} Agent => ${agent}`
+      const msg =
+        `${yellow("[JS Warning]")} on ${blue(path)}: ${JSON.stringify(warning.msg)}\n` +
+        `${yellow("[JS Warning]")} File  => ${warning.file}\n` +
+        `${yellow("[JS Warning]")} Line  => ${warning.line}\n` +
+        `${yellow("[JS Warning]")} Col   => ${warning.col}\n` +
+        `${yellow("[JS Warning]")} Error => ${JSON.stringify(warning.error)}\n` +
+        `${yellow("[JS Warning]")} Agent => ${agent}`
       logger.warn(msg)
-
     } else {
-      const msg= 
-      `${red('[JS Error]')} on ${blue(path)}: ${JSON.stringify(error.msg)}\n` +
-      `${red('[JS Error]')} File  => ${error.file}\n` +
-      `${red('[JS Error]')} Line  => ${error.line}\n` + 
-      `${red('[JS Error]')} Col   => ${error.col}\n` + 
-      `${red('[JS Error]')} Error => ${JSON.stringify(error.error)}\n` + 
-      `${red('[JS Error]')} Agent => ${agent}`
+      const msg =
+        `${red("[JS Error]")} on ${blue(path)}: ${JSON.stringify(error.msg)}\n` +
+        `${red("[JS Error]")} File  => ${error.file}\n` +
+        `${red("[JS Error]")} Line  => ${error.line}\n` +
+        `${red("[JS Error]")} Col   => ${error.col}\n` +
+        `${red("[JS Error]")} Error => ${JSON.stringify(error.error)}\n` +
+        `${red("[JS Error]")} Agent => ${agent}`
       logger.error(msg)
     }
 
-    ctx.body = {result: 1}
+    ctx.body = { ok: true, data: 1 }
   }
 
   const catch_js_error_router = new Router()
   catch_js_error_router.post(route, catch_js_error)
-  
-  app.use(catch_js_error_router.routes())
 
+  app.use(catch_js_error_router.routes())
 }
 
-export {init_route_catch_js_error}
+export { init_route_catch_js_error }

package/src/middleware/routes/robots.mjs

@@ -1,21 +1,18 @@
-import Router    from '@koa/router'
-
+import Router from "@koa/router"
 
 const ROBOTS_TXT = `User-agent: *
 Disallow: /
 `
 
 function init_route_robots(app) {
-
   async function robots(ctx) {
     ctx.body = ROBOTS_TXT
   }
 
   const robots_router = new Router()
-  robots_router.get('/robots.txt', robots)
-  
+  robots_router.get("/robots.txt", robots)
+
   app.use(robots_router.routes())
 }
 
-
-export {init_route_robots}
+export { init_route_robots }

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

@@ -1,214 +1,232 @@
-import {query_string_to_json} from '../utils.mjs'
-
+import { query_string_to_json } from "../utils.mjs"
 
 function attachCrudRoutes(router, crudConfigs, logger) {
-  
-  crudConfigs.map((crudConfig) => {
-
-    const prefix= crudConfig.prefix
-
-    crudConfig.routes.map(route => {
+  crudConfigs.forEach((crudConfig) => {
+    const prefix = crudConfig.prefix
 
+    crudConfig.routes.forEach((route) => {
       const _pack_body_field = (data) => {
-        if (route.bodyField == undefined) {
-          return data
+        if (route.bodyField === undefined) {
+          return { data }
         }
         return {
+          bodyField: route.bodyField,
           [route.bodyField]: data
         }
       }
-      
 
       const _crud_auth_callback = async (ctx, op) => {
-        const authenticated= ctx?.session?.authenticated === true
-    
+        const authenticated = ctx?.session?.authenticated === true
+
         const auth = route.auth
-        const checkAuth= (auth.require===true) || (auth.require==='read-only' && op==='w')
-        
+        const checkAuth = auth.require === true || (auth.require === "read-only" && op === "w")
+
         if (checkAuth) {
-    
           if (!authenticated) {
-            if (auth.action=='error') {
-              ctx.miolo.logger.error(`[router] Unauthorized access. Throwing error ${auth.error_code}`)
-              ctx.throw(
-                auth.error_code,
-                'Unauthorized',
-                {}
+            if (auth.action === "error") {
+              ctx.miolo.logger.error(
+                `[router] Unauthorized access. Throwing error ${auth.error_code}`
+              )
+              ctx.throw(auth.error_code, new Error("Unauthorized"), {})
+            } else if (auth.action === "redirect") {
+              ctx.miolo.logger.warn(
+                `[router] Unauthorized access. Redirecting to ${auth.redirect_url}`
               )
-            } 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
         }
-    
+
         return true
       }
 
       const _crud_callback = async (ctx, op, callback) => {
         const model = await ctx.miolo.db.get_model(route.name)
 
-        if (! model) {
+        if (!model) {
           ctx.miolo.logger.error(`[router] Could not get model for ${route.name}`)
           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= {}
+          if (!authenticated) {
+            ctx.body = {
+              ok: false,
+              error: "Unathorized"
+            }
             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= {}
+          if (!goon) {
+            ctx.body = {
+              ok: false,
+              error: "Not allowed"
+            }
             return
           }
 
-          const uid= ctx?.session?.user?.id
-          let fieldNames= {}
-          if (route.useUserFields.use===true) {
-            fieldNames= route.useUserFields.fieldNames
+          const uid = ctx?.session?.user?.id
+          let fieldNames = {}
+          if (route.useUserFields.use === true) {
+            fieldNames = route.useUserFields.fieldNames
           }
 
-          const uinfo= {
+          const uinfo = {
             uid: uid,
-            fieldNames,
+            fieldNames
           }
-          
-          result= await callback(model, uinfo)
-          
+
+          data = await callback(model, uinfo)
+
           if (route?.after) {
-            result= await route.after(ctx, result)
+            if (Array.isArray(route.after)) {
+              for (const after of route.after) {
+                data = await after(ctx, data)
+              }
+            } else {
+              data = await route.after(ctx, data)
+            }
           }
-        } catch(error) {
+        } 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) => {
-        await _crud_callback(ctx, 'r', async (model, _uinfo) => {
+        await _crud_callback(ctx, "r", async (model, _uinfo) => {
           const params = query_string_to_json(ctx.request.url)
           // TODO : handle transactions
-          const options= {transaction: undefined}
+          const options = { transaction: undefined }
           const data = await model.read(params, options)
           return data
         })
       }
-      
+
       const route_key_list = async (ctx) => {
-        await _crud_callback(ctx, 'r', async (model, _uinfo) => {
+        await _crud_callback(ctx, "r", async (model, _uinfo) => {
           // TODO : handle transactions
           const params = query_string_to_json(ctx.request.url)
-          const options= {transaction: undefined}
-          const data = await model.keyList(params, options)    
+          const options = { transaction: undefined }
+          const data = await model.keyList(params, options)
           return data
         })
       }
-      
+
       const route_find = async (ctx) => {
-        await _crud_callback(ctx, 'r', async (model, _uinfo) => {
+        await _crud_callback(ctx, "r", async (model, _uinfo) => {
           const params = query_string_to_json(ctx.request.url)
           // TODO : handle transactions
-          const options= {transaction: undefined}    
+          const options = { transaction: undefined }
           const data = await model.find(params.id, options)
           return data
         })
       }
 
       const route_distinct = async (ctx) => {
-        await _crud_callback(ctx, 'r', async (model, _uinfo) => {
+        await _crud_callback(ctx, "r", async (model, _uinfo) => {
           const params = query_string_to_json(ctx.request.url)
           // TODO : handle transactions
-          const options= {transaction: undefined}
+          const options = { transaction: undefined }
           const data = await model.distinct(params.distinct_field, params, options)
           return data
         })
       }
-      
+
       const route_save = async (ctx) => {
-        await _crud_callback(ctx, 'w', async (model, uinfo) => {
+        await _crud_callback(ctx, "w", async (model, uinfo) => {
           const params = ctx.request.body
           if (uinfo?.fieldNames?.created_by) {
             params[uinfo.fieldNames.created_by] = uinfo.uid
           }
           // TODO : handle transactions
-          const options= {transaction: undefined}
+          const options = { transaction: undefined }
           const data = await model.insert(params, options)
           return data
         })
       }
-      
+
       const route_update = async (ctx) => {
-        await _crud_callback(ctx, 'w', async (model, uinfo) => {
+        await _crud_callback(ctx, "w", async (model, uinfo) => {
           const params = ctx.request.body
           if (uinfo?.fieldNames?.last_update_by) {
             params[uinfo.fieldNames.last_update_by] = uinfo.uid
           }
           // TODO : handle transactions
-          const options= {transaction: undefined}    
-          const data = await model.update(params, {id: params.id}, options)
+          const options = { transaction: undefined }
+          const data = await model.update(params, { id: params.id }, options)
           return data
         })
       }
-      
+
       const route_delete = async (ctx) => {
-        await _crud_callback(ctx, 'w', async (model, _uinfo) => {
+        await _crud_callback(ctx, "w", async (model, _uinfo) => {
           const params = ctx.request.body
           // TODO : handle transactions
-          const options= {transaction: undefined}    
-          const data = await model.delete({id: params.id}, options)
+          const options = { transaction: undefined }
+          const data = await model.delete({ id: params.id }, options)
           return data
         })
       }
 
-      let url = (!prefix)
-        ? `/${route.url}`
-        : `/${prefix}/${route.url}`
-      
-      while (url.indexOf('//')>=0) {
-        url= url.replace(/\/\//g, "/")
+      let url = !prefix ? `/${route.url}` : `/${prefix}/${route.url}`
+
+      while (url.indexOf("//") >= 0) {
+        url = url.replace(/\/\//g, "/")
       }
 
       logger.debug(`[router] Routing table ${route.name} to ${url}`)
 
-      const allowRead = route.mode.indexOf('r')>=0
-      const allowDelete = route.mode.indexOf('w')>=0
-      const allowUpsave = (route.mode.indexOf('u')>=0) || allowDelete
-      
+      const allowRead = route.mode.indexOf("r") >= 0
+      const allowDelete = route.mode.indexOf("w") >= 0
+      const allowUpsave = route.mode.indexOf("u") >= 0 || allowDelete
+
       if (allowRead) {
-        router.get (`${url}/find`     , (ctx) => route_find(ctx))
-        router.get (`${url}/read`     , (ctx) => route_read(ctx))
-        router.get (`${url}/distinct` , (ctx) => route_distinct(ctx))
-        router.get (`${url}/key_list` , (ctx) => route_key_list(ctx)) 
+        router.get(`${url}/find`, (ctx) => route_find(ctx))
+        router.get(`${url}/read`, (ctx) => route_read(ctx))
+        router.get(`${url}/distinct`, (ctx) => route_distinct(ctx))
+        router.get(`${url}/key_list`, (ctx) => route_key_list(ctx))
       }
 
       if (allowUpsave) {
-        router.post(`${url}/save`     , (ctx) => route_save(ctx))
-        router.post(`${url}/update`   , (ctx) => route_update(ctx))
+        router.post(`${url}/save`, (ctx) => route_save(ctx))
+        router.post(`${url}/update`, (ctx) => route_update(ctx))
       }
       if (allowDelete) {
-        router.post(`${url}/delete`   , (ctx) => route_delete(ctx))
+        router.post(`${url}/delete`, (ctx) => route_delete(ctx))
       }
     })
   })
-
 }
 
-export default attachCrudRoutes
+export default attachCrudRoutes