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

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

@@ -1,19 +1,13 @@
-import merge from 'deepmerge'
-
-import {
-  DEFAULT_AUTH_USER,
-  DEFAULT_BEFORE_CALLBACK,
-  DEFAULT_AFTER_CALLBACK
-} from "../defaults.mjs"
-import { make_endpoint_from_fn } from '../utils.mjs'
+import merge from "deepmerge"
+import { DEFAULT_AUTH_USER } from "../defaults.mjs"
 
 /**
   {
     prefix: '/queries',
 
     auth,
-    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: [
@@ -21,88 +15,84 @@ 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 } or array of functions,
+        after :  async (ctx, data) => { return data } or array of functions,
+        schema: {
+          input: a Joi schema for validating input data,
+          output: a Joi schema for validating output data,
+        },
+        keep_body: false by default. If true, miolo wont wnsure ctx.body after callback.
       }
     ]
   }   
 */
 
 const getQueriesConfig = (config) => {
+  const instances = config?.queries || []
 
-
-  const instances= config?.queries || []
-
-  if (! instances) {
+  if (!instances) {
     return []
   }
 
-
-  if (! Array.isArray(instances)) {
+  if (!Array.isArray(instances)) {
     return []
   }
 
-  let output= []
-  
-  instances.map((instance) => {  
+  const output = []
 
-    const routes= instance?.routes
+  instances.forEach((instance) => {
+    const routes = instance?.routes
 
-    if (! routes) {
+    if (!routes) {
       return
     }
 
-    if (! Array.isArray(routes)) {
+    if (!Array.isArray(routes)) {
       return
     }
-    
-    const comm_before = instance?.before || config?.before || DEFAULT_BEFORE_CALLBACK
-    const comm_after = instance?.after || config?.after || DEFAULT_AFTER_CALLBACK
-
-    const comm_auth= merge.all([
-      DEFAULT_AUTH_USER,
-      instance?.auth || {},
-      config?.auth || {}
-    ])
-    
-    let parsed_routes= []
+
+    const comm_before = instance?.before || config?.before
+    const comm_after = instance?.after || config?.after
+
+    const comm_auth = merge.all([DEFAULT_AUTH_USER, instance?.auth || {}, config?.auth || {}])
+
+    const parsed_routes = []
 
     for (const route of routes) {
-      if (! route.url) {
+      if (!route.url) {
         continue
       }
-      
-      let cb=undefined
-      if ((! route.callback) && (! route.callback_fn)) {
-        continue
-      } else {
-        cb = route.callback || make_endpoint_from_fn(route.callback_fn)
-      }
 
-      const parsed_route= {
+      const cb = route?.callback
+
+      const parsed_route = {
         url: route.url,
-        method: route?.method || 'GET', 
+        method: route?.method || "GET",
         callback: cb,
 
-        auth: merge.all([
-          comm_auth,
-          route?.auth  || {}
-        ]),
+        auth: merge.all([comm_auth, route?.auth || {}]),
 
         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)
     }
 
     output.push({
-      prefix: instance?.prefix || '',
+      prefix: instance?.prefix || "",
       routes: parsed_routes
     })
   })

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

@@ -1,38 +1,53 @@
 /**
  * Transform a query string to a JSON object
  */
-import qs from 'qs'
+import qs from "qs"
 
-export function query_string_to_json(url) {     
-  let search= url.indexOf('?')>=0 ? url.substr(url.indexOf('?')+1) : '';
-  if (search) {
-    return qs.parse(search)
-  }
-  return {}
-}
+export function query_string_to_json(url) {
+  const search = url.includes("?") ? url.substring(url.indexOf("?") + 1) : ""
+  if (!search) return {}
 
-export function make_endpoint_from_fn(fn, field) {
-
-  async function endpoint_from_fn(ctx) {    
-    const params = ctx.request.body
-    try {
-      ctx.miolo.logger.debug(`[router] ${fn.name}() Calling with params ${JSON.stringify(params)}`)
-    } catch (_) {
-      ctx.miolo.logger.debug(`[router] ${fn.name}()Calling with params (?)`)
+  const parsed = qs.parse(search)
+  //
+  function reviveTypes(value) {
+    if (Array.isArray(value)) return value.map(reviveTypes)
+    if (value && typeof value === "object") {
+      const result = {}
+      for (const key in value) {
+        if (Object.hasOwn(value, key)) result[key] = reviveTypes(value[key])
+      }
+      return result
     }
+    // Try to convert to boolean, number o null
+    if (value === "true") return true
+    if (value === "false") return false
+    if (value === "null") return null
+    if (!Number.isNaN(Number(value)) && value !== "") return Number(value)
+    return value
+  }
 
-    const result = await fn(ctx.miolo, params)
+  return reviveTypes(parsed)
+}
 
-    try {
-      ctx.miolo.logger.debug(`[router] ${fn.name}() Called with result ${JSON.stringify(result)}`)
-    } catch (_) {
-      ctx.miolo.logger.debug(`[router] ${fn.name}() Called with result (?)`)
+export function ensure_response_is_ok_data(ctx, response) {
+  if (response?.ok === undefined && response?.data === undefined && response?.error === undefined) {
+    ctx.miolo.logger.debug(
+      `[router] Response without ok/[data/error] fields. It is: ${JSON.stringify(response)}. Let's wrap it on an ok response`
+    )
+    return {
+      ok: true,
+      data: response || {}
+    }
+  }
+  if (response?.error !== undefined) {
+    return {
+      ok: false,
+      error: response.error,
+      data: response?.data
     }
-
-    ctx.body = result
   }
-  
-  Object.defineProperty(endpoint_from_fn, 'name', {value: fn.name, writable: false})
 
-  return endpoint_from_fn
+  const ok = response?.ok !== false
+  const data = response?.data !== undefined ? response.data : response !== undefined ? response : {}
+  return { ok, data }
 }

package/src/middleware/ssr/context.mjs

@@ -1,12 +1,10 @@
-
 // context builder
-export const ssr_context_builder_make = (app, ssrConfig) => {
-
+export const ssr_context_builder_make = (_app, _ssrConfig) => {
   const ssr_build_context = (ctx, config, ssr_data) => {
     const isAuthed = ctx?.session?.authenticated === true
     const user = ctx?.session?.user
-    
-    const context= {
+
+    const context = {
       config,
       user,
       authenticated: isAuthed,
@@ -16,6 +14,6 @@ export const ssr_context_builder_make = (app, ssrConfig) => {
 
     return context
   }
-  
+
   return ssr_build_context
-}
+}

package/src/middleware/ssr/html.mjs

@@ -1,18 +1,30 @@
-import path from 'path'
-import { readFileSync } from 'fs'
-import { fallbackIndexHTML } from './fallbackIndex.mjs'
+import { readFileSync } from "node:fs"
+import path from "node:path"
+import { nanoid } from "nanoid"
+import { fallbackIndexHTML } from "./fallbackIndex.mjs"
+
+let _script_version
+const get_script_version = () => {
+  if (!_script_version) {
+    _script_version = nanoid()
+  }
+  return _script_version
+}
 
 function _html_read(htmlFile) {
+  if (!htmlFile) {
+    return fallbackIndexHTML
+  }
   try {
-    const isProduction = process.env.NODE_ENV === 'production'
+    const isProduction = process.env.NODE_ENV === "production"
     const proot = (p) => path.join(process.cwd(), p)
-    const indexHTMLPath=  proot(isProduction 
-        ? `${process.env.MIOLO_BUILD_CLIENT_DEST}/index.html`
-        : htmlFile) 
+    const indexHTMLPath = proot(
+      isProduction ? `${process.env.MIOLO_BUILD_CLIENT_DEST}/index.html` : htmlFile
+    )
 
-    const indexHTML = readFileSync(indexHTMLPath, 'utf8')
+    const indexHTML = readFileSync(indexHTMLPath, "utf8")
     return indexHTML
-  } catch(error) {
+  } catch (error) {
     console.error(`[miolo] Error reading HTML file ${htmlFile}: ${error}`)
     return fallbackIndexHTML
   }
@@ -21,80 +33,91 @@ function _html_read(htmlFile) {
 function _feed_html(htmlString, client, context, ssr_html) {
   const contextScript = `<script> window.__CONTEXT = ${JSON.stringify(context, null, 2)}</script>`
   const rootDiv = `<div id="root">${ssr_html}</div>`
-  
-  const webClient = client.startsWith('./') 
-    ? client.replace('./', '/')
-    : client.startsWith('/') 
-    ? client
-    : `/${client}`
+
+  const webClient = client.startsWith("./")
+    ? client.replace("./", "/")
+    : client.startsWith("/")
+      ? client
+      : `/${client}`
 
   const linkTag =
-    process.env.NODE_ENV === 'production'
-      ? `  <script src="${webClient}" async></script>`
+    process.env.NODE_ENV === "production"
+      ? `  <script src="${webClient}?v=${get_script_version()}" async></script>`
       : `  <script type="module" src="${webClient}"></script>`
-  
+
   // head
   const headCloseTagRegex = /(<\/head>)/i
-  htmlString= htmlString.replace(headCloseTagRegex, `${contextScript}\n$&`)
-  
+  htmlString = htmlString.replace(headCloseTagRegex, `${contextScript}\n$&`)
+
   // body
   const bodyCloseTagRegex = /(<\/body>)/i
-  htmlString= htmlString.replace(bodyCloseTagRegex, `${rootDiv}\n${linkTag}\n$&`)
-  
+  htmlString = htmlString.replace(bodyCloseTagRegex, `${rootDiv}\n${linkTag}\n$&`)
+
   return htmlString
 }
 
-
 // HTML renderer
-export const ssr_html_renderer_make = async (app, ssrConfig, htmlFile, client, devRender= undefined) => {
-  const isProduction = process.env.NODE_ENV === 'production'
+export const ssr_html_renderer_make = async (
+  app,
+  ssrConfig,
+  htmlFile,
+  client,
+  devRender = undefined
+) => {
+  const isProduction = process.env.NODE_ENV === "production"
 
   // check HTML
   const tmplHtml = _html_read(htmlFile)
 
   const ssr_html_renderer = async (ctx, context) => {
-    let base_html= tmplHtml
-    
+    let base_html = tmplHtml
+
     // prepare render() function for server entry
 
     // fallback function
-    let render = (ctx, context) => ''
+    let render = (_ctx, _context) => ""
     // if vite and DEV
-    if ((!isProduction) && (app?.vite)) {
+    if (!isProduction && app?.vite) {
       if (devRender) {
         const [dev_html, dev_render] = await devRender(app, ctx, base_html, ssrConfig)
         if (dev_render) {
-          base_html= dev_html
-          render= dev_render
+          base_html = dev_html
+          render = dev_render
         }
       }
-    // if non-vite or prod
+      // if non-vite or prod
     } else {
       try {
-        render = (await import(ssrConfig.server)).render
-      } catch(error) {
-        ctx.miolo.logger.error(`SSR Error for ${ssrConfig.server}:\n${error.toString()}\n${error.stack}`)
+        if (ssrConfig?.server !== "false") {
+          render = (await import(ssrConfig.server)).render
+        }
+      } catch (error) {
+        ctx.miolo.logger.error(
+          `SSR Error for ${ssrConfig.server}:\n${error.toString()}\n${error.stack}`
+        )
       }
     }
 
     // render the result
-    let ssr_html= ''
+    let ssr_html = ""
     try {
       ssr_html = render(ctx, context)
-    } catch(error) {
-      ctx.miolo.logger.error(`SSR Error rendering server entry:\n${error.toString()}\n${error.stack}`)
-    
-      ssr_html= `
+    } catch (error) {
+      ctx.miolo.logger.error(
+        `SSR Error rendering server entry:\n${error.toString()}\n${error.stack}`
+      )
+
+      ssr_html = `
       <div>
         MIOLO: SSR Error: ${error.stack}
       </div>      
       `
     }
-    
+
     const parsed_html = _feed_html(base_html, client, context, ssr_html)
 
     return parsed_html
   }
-  
+
   return ssr_html_renderer
-}
+}

package/src/middleware/ssr/loader.mjs

@@ -1,24 +1,21 @@
 // ssr loader
-export const ssr_loader_make = (app, ssrConfig) => {
-
+export const ssr_loader_make = (_app, ssrConfig) => {
   const ssr_loader = async (ctx) => {
-    let res= {}
+    let res = {}
     try {
       if (ssrConfig?.loader) {
-        res= await ssrConfig.loader(ctx)
+        res = await ssrConfig.loader(ctx)
       }
-    } catch(e) {
-      const tit= 'Error produced by loader in ssrConfig'
-      const inf= `URL: ${ctx.request.url}\nFields: ${JSON.stringify(ctx.request?.fields || {})}`
-      const det= e?.stack
-        ? `${e.toString()}\n${e.stack}`
-        : e.toString()
-      const all= `${tit}\n${inf}\n${det}`
-    
+    } catch (e) {
+      const tit = "Error produced by loader in ssrConfig"
+      const inf = `URL: ${ctx.request.url}\nFields: ${JSON.stringify(ctx.request?.fields || {})}`
+      const det = e?.stack ? `${e.toString()}\n${e.stack}` : e.toString()
+      const all = `${tit}\n${inf}\n${det}`
+
       ctx.miolo.logger.error(all)
     }
-    return res  
+    return res
   }
 
   return ssr_loader
-}
+}

package/src/middleware/ssr/ssr_render.mjs

@@ -1,46 +1,63 @@
-import { ssr_context_builder_make } from './context.mjs'
-import { ssr_loader_make } from './loader.mjs'
-import { ssr_html_renderer_make } from './html.mjs'
-
-
-export async function init_ssr_render_middleware(app, config, devRender= undefined) {
+import { ssr_context_builder_make } from "./context.mjs"
+import { ssr_html_renderer_make } from "./html.mjs"
+import { ssr_loader_make } from "./loader.mjs"
 
+export async function init_ssr_render_middleware(app, config, devRender = undefined) {
   const ssrConfig = config.build.ssr
   const httpConfig = config.http
   const authConfig = config?.auth || {}
-  // const socketConfig = config?.socket || {}
+  const socketConfig = config?.socket || {}
 
   const ssr_build_context = ssr_context_builder_make(app, ssrConfig)
   const ssr_loader = ssr_loader_make(app, ssrConfig)
-  const ssr_html_renderer = await ssr_html_renderer_make(app, ssrConfig, config.build.html, config.build.client, devRender)
+  const ssr_html_renderer = await ssr_html_renderer_make(
+    app,
+    ssrConfig,
+    config.build.html,
+    config.build.client,
+    devRender
+  )
 
   async function render_ssr_middleware(ctx) {
     try {
-      const config= {
+      const config = {
         hostname: httpConfig?.hostname,
         port: httpConfig?.port,
         catcher_url: httpConfig?.catcher_url,
-        login_url: authConfig?.credentials?.url_login,
-        logout_url: authConfig?.credentials?.url_logout,
-        //socket: {
-        //  enabled: socketConfig?.enabled===true,
-        //  config: socketConfig?.config?.cli || {}
-        //}
+        auth_method: ctx.session?.auth_method,
+        log_level: ctx.miolo.logger.level,
+        login_url:
+          ctx.session?.auth_method === "google"
+            ? authConfig?.passport?.google_url_login
+            : authConfig?.passport?.local_url_login,
+        logout_url:
+          ctx.session?.auth_method === "google"
+            ? authConfig?.passport?.google_url_logout
+            : authConfig?.passport?.local_url_logout,
+        socket: {
+          enabled: socketConfig?.enabled === true,
+          url: socketConfig?.config?.cli?.url || null,
+          options: socketConfig?.config?.cli?.options || {}
+        }
       }
+      ctx.miolo.logger.debug(
+        `[render-ssr] rendering an ${ctx?.session?.authenticated === true ? "authenticated" : "unauthenticated"} context...`
+      )
 
       const ssr_data = await ssr_loader(ctx)
       const context = ssr_build_context(ctx, config, ssr_data)
       const rendered_html = await ssr_html_renderer(ctx, context)
-      
-      ctx.miolo.logger.debug(`[render-ssr] Returned body is ${Buffer.byteLength(rendered_html, 'utf8')} bytes`)
 
-      ctx.type = 'text/html'
-      ctx.body= rendered_html
-      ctx.status = 200
-    } catch(e) {
+      ctx.miolo.logger.debug(
+        `[render-ssr] Returned body is ${Buffer.byteLength(rendered_html, "utf8")} bytes`
+      )
 
+      ctx.type = "text/html"
+      ctx.body = rendered_html
+      ctx.status = 200
+    } catch (e) {
       ctx.body = e.stack
-      ctx.type = 'text/html'
+      ctx.type = "text/html"
       ctx.status = 500
     }
   }

package/src/middleware/static/index.mjs

@@ -1,27 +1,46 @@
-import koa_mount from 'koa-mount'
-import koa_serve from 'koa-static'
-import koa_favicon from 'koa-favicon'
-import {existsSync} from 'fs'
+import { existsSync } from "node:fs"
+import koa_favicon from "koa-favicon"
+import koa_mount from "koa-mount"
+import koa_serve from "koa-static"
 
-const init_static_middleware = ( app, config ) => {
-  const {favicon, folders} = config
+const init_static_middleware = (app, config) => {
+  const { favicon, folders, headers } = config
 
   if (favicon && existsSync(favicon)) {
     app.context.miolo.logger.debug(`[static] Serving favicon from -${favicon}-`)
     app.use(koa_favicon(favicon))
   } else {
-    app.context.miolo.logger.warn(`[static] Cannot serve favicon from -${favicon}- (does not exist)`)
+    app.context.miolo.logger.warn(
+      `[static] Cannot serve favicon from -${favicon}- (does not exist)`
+    )
   }
-  
-  for(const [froute, fpath] of Object.entries(folders)) {
+
+  // Do not cache some specific files
+  app.use(async (ctx, next) => {
+    for (const [fpath, fheaders] of Object.entries(headers)) {
+      if (ctx.path === fpath) {
+        app.context.miolo.logger.info(
+          `[static] Setting headers for -${fpath}- ${Object.keys(fheaders).join(", ")}`
+        )
+        for (const [key, value] of Object.entries(fheaders)) {
+          ctx.set(key, value)
+        }
+        break
+      }
+    }
+    await next()
+  })
+
+  for (const [froute, fpath] of Object.entries(folders)) {
     if (fpath && existsSync(fpath)) {
-      app.context.miolo.logger.debug(`[static] Mounting static folder ${froute} => -${fpath}-`)
-      app.use(koa_mount(froute, koa_serve(fpath, {index: false})))
+      app.context.miolo.logger.info(`[static] Mounting static folder ${froute} => -${fpath}-`)
+      app.use(koa_mount(froute, koa_serve(fpath, { index: false })))
     } else {
-      app.context.miolo.logger.warn(`[static] Cannot mount static folder ${froute} => -${fpath}- (does not exist)`)
-
+      app.context.miolo.logger.warn(
+        `[static] Cannot mount static folder ${froute} => -${fpath}- (does not exist)`
+      )
     }
   }
 }
 
-export {init_static_middleware}
+export { init_static_middleware }