miolo 3.0.0-beta.195 → 3.0.0-beta.196

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo",
-  "version": "3.0.0-beta.195",
+  "version": "3.0.0-beta.196",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -47,7 +47,7 @@
     "@babel/plugin-proposal-decorators": "^7.29.0",
     "@babel/preset-env": "^7.29.5",
     "@babel/preset-react": "^7.28.5",
-    "@dotenvx/dotenvx": "^1.65.0",
+    "@dotenvx/dotenvx": "^1.66.0",
     "@koa/bodyparser": "^6.1.0",
     "@koa/cors": "^5.0.0",
     "@koa/router": "^15.5.0",
@@ -60,7 +60,7 @@
     "@rollup/plugin-replace": "^6.0.3",
     "@tailwindcss/postcss": "^4.3.0",
     "@tailwindcss/vite": "^4.3.0",
-    "@vitejs/plugin-react": "^6.0.1",
+    "@vitejs/plugin-react": "^6.0.2",
     "autoprefixer": "^10.5.0",
     "cacheiro": "^0.5.0-beta.11",
     "calustra": "^1.0.0-beta.14",
@@ -86,7 +86,7 @@
     "nodemailer": "^8.0.7",
     "passport-google-oauth20": "^2.0.0",
     "passport-local": "^1.0.0",
-    "rollup": "^4.60.3",
+    "rollup": "^4.60.4",
     "rollup-plugin-node-externals": "^9.0.1",
     "rollup-plugin-postcss": "^4.0.2",
     "socket.io": "^4.8.3",
@@ -94,7 +94,7 @@
     "statuses": "^2.0.2",
     "tailwindcss": "^4.3.0",
     "tinguir": "^0.0.7",
-    "vite": "^8.0.12",
+    "vite": "^8.0.13",
     "winston": "^3.19.0",
     "winston-daily-rotate-file": "^5.0.0",
     "yargs-parser": "^22.0.0"

package/src/config/defaults.mjs

@@ -223,8 +223,11 @@ export default function make_config_defaults() {
               auth: ...,
               before:  async (ctx) => { return true/false } or array of functions,
               after :  async (ctx, data) => { return data } or array of functions,
-              schema: a Joi schema,
-              keep_body: false by default. If true, miolo wont wnsure ctx.body after callback.
+              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 ensure ctx.body after callback.
             },          
           ], 
         },

package/src/engines/schema/diffObjs.mjs

@@ -0,0 +1,41 @@
+export function diffObjs(o1, o2) {
+  const missingKeys = []
+
+  function findMissing(obj1, obj2, prefix = "") {
+    for (const key in obj1) {
+      if (Object.hasOwn(obj1, key)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key
+
+        if (!obj2 || !(key in obj2)) {
+          missingKeys.push(`'${fullKey}'`)
+        } else if (
+          typeof obj1[key] === "object" &&
+          obj1[key] !== null &&
+          typeof obj2[key] === "object" &&
+          obj2[key] !== null &&
+          !Array.isArray(obj1[key]) &&
+          !Array.isArray(obj2[key])
+        ) {
+          findMissing(obj1[key], obj2[key], fullKey)
+        }
+      }
+    }
+  }
+
+  findMissing(o1, o2)
+
+  if (missingKeys.length === 0) {
+    return ""
+  }
+
+  const isPlural = missingKeys.length > 1
+  let keysStr = ""
+  if (!isPlural) {
+    keysStr = missingKeys[0]
+  } else {
+    const lastKey = missingKeys.pop()
+    keysStr = `${missingKeys.join(", ")} and ${lastKey}`
+  }
+
+  return keysStr
+}

package/src/engines/schema/index.mjs

@@ -1,52 +1,4 @@
-import Joi from "joi"
+import { with_miolo_input_schema } from "./input.mjs"
+import { with_miolo_output_schema } from "./output.mjs"
 
-export function with_miolo_schema(fn, schema) {
-  return async (ctx, params) => {
-    let error
-
-    // Check schema is actually a schema
-    if (!schema || !Joi.isSchema(schema)) {
-      error = `Expecting schema for ${fn.name} but something else was found (${typeof schema})`
-      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
-      throw new Error(error)
-    }
-
-    // perform validation
-    let v
-    try {
-      v = schema.validate(params)
-    } catch (uerror) {
-      error = `Unexpected error validating data for ${fn.name}: ${uerror?.message || uerror}`
-      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
-      throw new Error(error)
-    }
-
-    // raise validation errors
-    if (v?.error) {
-      error = `Schema invalidated data for ${fn.name}: ${v.error}\n${v.error.annotate(true)}`
-      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
-      throw new Error(error)
-    }
-
-    // check parsed value is ok
-    if (!v?.value) {
-      const description = schema.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) {
-        error = `Schema returned unknown result for ${fn.name}: ${JSON.stringify(v)}`
-        ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
-        throw new Error(error)
-      }
-    }
-
-    return await fn(ctx, v.value)
-  }
-}
+export { with_miolo_input_schema, with_miolo_output_schema }

package/src/engines/schema/input.mjs

@@ -0,0 +1,52 @@
+import Joi from "joi"
+
+export function with_miolo_input_schema(fn, schema) {
+  return async (ctx, params) => {
+    let error
+
+    // Check schema is actually a schema
+    if (!schema || !Joi.isSchema(schema)) {
+      error = `Expecting input schema for ${fn.name} but something else was found (${typeof schema})`
+      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+      throw new Error(error)
+    }
+
+    // perform validation
+    let v
+    try {
+      v = schema.validate(params)
+    } catch (uerror) {
+      error = `Unexpected error validating input data for ${fn.name}: ${uerror?.message || uerror}`
+      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+      throw new Error(error)
+    }
+
+    // raise validation errors
+    if (v?.error) {
+      error = `Input schema invalidated data for ${fn.name}: ${v.error}\n${v.error.annotate(true)}`
+      ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+      throw new Error(error)
+    }
+
+    // check parsed value is ok
+    if (!v?.value) {
+      const description = schema.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) {
+        error = `Input schema returned unknown result for ${fn.name}: ${JSON.stringify(v)}`
+        ctx.miolo.logger.silly(`[validation][${fn.name}] ${error}`)
+        throw new Error(error)
+      }
+    }
+
+    return await fn(ctx, v.value)
+  }
+}

package/src/engines/schema/output.mjs

@@ -0,0 +1,63 @@
+import Joi from "joi"
+import { diffObjs } from "./diffObjs.mjs"
+
+export function with_miolo_output_schema(fn, schema) {
+  const fnName = fn?.name ? `[${fn.name}]` : ""
+
+  return async (ctx, params) => {
+    let error
+
+    // Check schema is actually a schema
+    if (!schema || !Joi.isSchema(schema)) {
+      error = `Expecting output schema for ${fn.name} but something else was found (${typeof schema})`
+      ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+      throw new Error(error)
+    }
+
+    // Call the function first
+    const result = await fn(ctx, params)
+
+    // perform validation over the result
+    let v
+    try {
+      v = schema.validate(result, { stripUnknown: true })
+    } catch (uerror) {
+      error = `Unexpected error validating output data for ${fn.name}: ${uerror?.message || uerror}`
+      ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+      throw new Error(error)
+    }
+
+    // raise validation errors
+    if (v?.error) {
+      error = `Output schema invalidated data for ${fn.name}: ${v.error}\n${v.error.annotate(true)}`
+      ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+      throw new Error(error)
+    }
+
+    // check parsed value is ok
+    if (!v?.value) {
+      const description = schema.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) {
+        error = `Output schema returned unknown result for ${fn.name}: ${JSON.stringify(v)}`
+        ctx.miolo.logger.silly(`[validation]${fnName} ${error}`)
+        throw new Error(error)
+      }
+    }
+
+    const diff = diffObjs(result, v.value)
+    if (diff) {
+      ctx.miolo.logger.debug(`[validation]${fnName} Output schema has removed ${diff}`)
+    }
+
+    return v.value
+  }
+}

package/src/index.mjs

@@ -3,7 +3,7 @@ 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_schema } from "./engines/schema/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"
 
@@ -18,5 +18,6 @@ export {
   miolo_emailer,
   miolo_logger,
   miolo_parser,
-  with_miolo_schema
+  with_miolo_input_schema,
+  with_miolo_output_schema
 }

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

@@ -88,25 +88,27 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
             }
           }
 
-          if (route?.schema) {
+          const inputSchema = route?.schema?.input
+
+          if (inputSchema) {
             // Check schema is actually a schema
-            if (!Joi.isSchema(route.schema)) {
+            if (!Joi.isSchema(inputSchema)) {
               ctx.miolo.logger.error(
-                `[router] Expecting schema at ${url} but something else was found (${typeof route.schema})`
+                `[router] Expecting input schema at ${url} but something else was found (${typeof inputSchema})`
               )
               ctx.body = {
                 ok: false,
-                error: "Invalid schema"
+                error: "Invalid input schema"
               }
               return
             }
 
             try {
-              const v = route.schema.validate(ctx.request.body)
+              const v = inputSchema.validate(ctx.request.body)
 
               if (v?.error) {
                 ctx.miolo.logger.warn(
-                  `[router] Schema invalidated data for ${url}: ${v.error}\n${v.error.annotate(true)}`
+                  `[router] Input schema invalidated data for ${url}: ${v.error}\n${v.error.annotate(true)}`
                 )
                 ctx.body = {
                   ok: false,
@@ -114,10 +116,12 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
                 }
                 return
               } else if (v?.value) {
-                ctx.miolo.logger.silly(`[router] Schema validated data for ${url} successfully`)
+                ctx.miolo.logger.silly(
+                  `[router] Input schema validated data for ${url} successfully`
+                )
                 ctx.request.body = v.value
               } else {
-                const description = route.schema.describe()
+                const description = inputSchema.describe()
 
                 // Check if schema was deliberately set to allow only null
                 //  schema = Joi.any().allow(null)
@@ -129,18 +133,18 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
 
                 if (isOnlyNull) {
                   ctx.miolo.logger.silly(
-                    `[router] Schema allowed null param to ${url} successfully`
+                    `[router] Input schema allowed null param to ${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.`
+                    `[router] Input 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}`
+                `[router] Error validating input schema at ${url}: ${error?.message || error}`
               )
               ctx.body = {
                 ok: false,
@@ -164,6 +168,88 @@ function attachQueriesRoutes(router, queriesConfigs, logger) {
             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}`

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

@@ -27,7 +27,10 @@ import { DEFAULT_AUTH_USER } from "../defaults.mjs"
         auth,
         before:  async (ctx) => { return true/false } or array of functions,
         after :  async (ctx, data) => { return data } or array of functions,
-        schema: a Joi schema,
+        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.
       }
     ]

package/template/.agent/skills/miolo-routing/SKILL.md

@@ -164,10 +164,17 @@ export default [{
       url: '/item/search',
       auth,
       callback: r_item_search,
-      schema: Joi.object({
-        query: Joi.string().min(3).required(),
-        limit: Joi.number().min(1).max(100).default(20)
-      })
+      schema: {
+        input: Joi.object({
+          query: Joi.string().min(3).required(),
+          limit: Joi.number().min(1).max(100).default(20)
+        }),
+        output: Joi.object({
+          ok: Joi.boolean().required(),
+          data: Joi.array().items(Joi.object()).required(),
+          error: Joi.string().optional()
+        })
+      }
     }
   ]
 }]
@@ -175,7 +182,7 @@ export default [{
 
 **Wrapper function:**
 ```javascript
-import { with_miolo_schema } from 'miolo'
+import { with_miolo_input_schema } from 'miolo'
 import Joi from 'joi'
 
 const itemSchema = Joi.object({
@@ -190,7 +197,7 @@ export default [{
       method: 'POST',
       url: '/item/save',
       auth,
-      callback: with_miolo_schema(r_item_upsave, itemSchema)
+      callback: with_miolo_input_schema(r_item_upsave, itemSchema)
     }
   ]
 }]
@@ -305,7 +312,7 @@ export async function r_item_find(ctx, params) {
 2. **Consistent naming** - Routes start with `r_`, database functions with `db_`
 3. **Always log** - Use `ctx.miolo.logger` for all operations (`info`level)
 4. **Return consistent format** - Always `{ ok, data }` or `{ ok, error }`
-5. **Validate inputs** - Use Joi schemas for validation
+5. **Validate inputs (and outputs)** - Use Joi schemas for validation
 6. **Handle errors** - Wrap in try/catch, return meaningful errors
 7. **Check user access** - Use `ctx.state.user` to verify permissions
 8. **Keep handlers thin** - Business logic in `db/io/`, routes only handle HTTP

package/template/.agent/skills/miolo-schemas/SKILL.md

@@ -1,18 +1,18 @@
 ---
 name: miolo-schemas
-description: Joi validation schemas and patterns for miolo applications. Use when implementing request/parameter validation for routes or database functions, creating reusable schema components, or using with_miolo_schema wrapper.
+description: Joi validation schemas and patterns for miolo applications. Use when implementing request/parameter validation for routes or database functions, creating reusable schema components, or using with_miolo_input_schema and with_miolo_output_schema wrappers.
 ---
 
 # Miolo Validation Schemas
 
 Joi validation schema patterns for miolo routes and database functions.
 
-## Schema Wrapper: with_miolo_schema
+## Schema Wrappers: with_miolo_input_schema and with_miolo_output_schema
 
-Use `with_miolo_schema` to wrap route handlers and database functions with validation:
+Use `with_miolo_input_schema` to wrap route handlers and database functions to validate incoming parameters.
 
 ```javascript
-import { with_miolo_schema } from 'miolo'
+import { with_miolo_input_schema } from 'miolo'
 import Joi from 'joi'
 
 // Define schema
@@ -29,17 +29,39 @@ async function _r_todo_upsave(ctx, params) {
   // ...
 }
 
-export const r_todo_upsave = with_miolo_schema(_r_todo_upsave, todoSchema)
+export const r_todo_upsave = with_miolo_input_schema(_r_todo_upsave, todoSchema)
 ```
 
 **Key benefits:**
-- Automatic validation before function execution
+- Automatic validation before function execution (input) or before sending the response (output)
 - Validation errors handled automatically
 - Default values applied
 - Type coercion
+- Extraneous fields removed (diff log generated on output schemas)
+
+### Using `with_miolo_output_schema`
+
+Use `with_miolo_output_schema` to ensure that data returned by a function matches the expected format, automatically stripping any extra properties not defined in the schema.
+
+```javascript
+import { with_miolo_output_schema } from 'miolo'
+import Joi from 'joi'
+
+const todoOutputSchema = Joi.object({
+  ok: Joi.boolean().required(),
+  data: Joi.object({
+    id: Joi.number().required(),
+    description: Joi.string().required()
+  })
+})
+
+export const db_todo_insert = with_miolo_output_schema(_db_todo_insert, todoOutputSchema)
+```
 
 ## Using Schemas in Routes
 
+Route definitions accept a `schema` object that can contain both `input` and `output` schemas:
+
 ### Inline Schema (Route Definition)
 
 Define schema directly in route configuration:
@@ -55,9 +77,15 @@ export default [{
       url: '/todo/last_hours',
       auth,
       callback: r_todo_count_last_hours,
-      schema: Joi.object({
-        hours: Joi.number().min(1).max(24).required()
-      })
+      schema: {
+        input: Joi.object({
+          hours: Joi.number().min(1).max(24).required()
+        }),
+        output: Joi.object({
+          ok: Joi.boolean().required(),
+          data: Joi.number().required()
+        })
+      }
     }
   ]
 }]
@@ -68,7 +96,7 @@ export default [{
 Wrap the handler function with schema:
 
 ```javascript
-import { with_miolo_schema } from 'miolo'
+import { with_miolo_input_schema } from 'miolo'
 import Joi from 'joi'
 
 const todoSchema = Joi.object({
@@ -82,7 +110,7 @@ export default [{
       method: 'POST',
       url: '/todo/fake',
       auth,
-      callback: with_miolo_schema(r_todo_insert_fake, todoSchema)
+      callback: with_miolo_input_schema(r_todo_insert_fake, todoSchema)
     }
   ]
 }]
@@ -93,7 +121,7 @@ export default [{
 **Strongly recommended** to validate database function parameters:
 
 ```javascript
-import { with_miolo_schema } from 'miolo'
+import { with_miolo_input_schema } from 'miolo'
 import Joi from 'joi'
 import { opt_int, bool_null, opt_str_null } from '#server/utils/schema.mjs'
 
@@ -118,13 +146,13 @@ const todo_read_schema = Joi.object({
 })
 
 // Export wrapped function
-export const db_todo_read = with_miolo_schema(_db_todo_read, todo_read_schema)
+export const db_todo_read = with_miolo_input_schema(_db_todo_read, todo_read_schema)
 ```
 
 **Pattern:**
 1. Create private implementation function with `_` prefix
 2. Define schema using partial schemas from `utils/schema.mjs`
-3. Export wrapped function with `with_miolo_schema`
+3. Export wrapped function with `with_miolo_input_schema`
 
 ## Partial Schemas (Reusable Components)
 
@@ -254,14 +282,15 @@ const schema = Joi.object({
 
 ## Best Practices
 
-1. **Always validate route parameters** - Use schema in route definition or with_miolo_schema
-2. **Strongly recommended for db functions** - Wrap all db_*() functions with schemas
+1. **Always validate route parameters and outputs** - Use `schema: { input, output }` in route definition.
+2. **Strongly recommended for db functions** - Wrap all db_*() functions with schemas using `with_miolo_input_schema` or `with_miolo_output_schema`.
 3. **Use partial schemas** - Reuse common patterns from `utils/schema.mjs`
 4. **Add to partial schemas** - Extend `utils/schema.mjs` with new reusable patterns
 5. **Private + public pattern** - Use `_function_name` for implementation, export wrapped version
 6. **Default values** - Use `.default()` for optional fields with sensible defaults
 7. **Allow null carefully** - Only use `.allow(null)` when null is a valid business value
 8. **Validate early** - Validation should happen before any business logic
+9. **Remove unused properties** - `with_miolo_output_schema` ensures the client doesn't get extraneous fields.
 
 ## Extending Partial Schemas
 

package/template/package.json

@@ -44,15 +44,15 @@
     "farrapa": "^3.0.0-beta.10",
     "intre": "^3.0.0-beta.4",
     "joi": "^18.2.1",
-    "lucide-react": "^1.14.0",
-    "miolo-cli": "^3.0.0-beta.195",
+    "lucide-react": "^1.16.0",
+    "miolo-cli": "^3.0.0-beta.196",
     "miolo-model": "file:../miolo-model",
-    "miolo-react": "^3.0.0-beta.195",
+    "miolo-react": "^3.0.0-beta.196",
     "next-themes": "^0.4.6",
     "radix-ui": "^1.4.3",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
-    "react-router": "^7.15.0",
+    "react-router": "^7.15.1",
     "recharts": "^3.8.1",
     "sonner": "^2.0.7",
     "tailwind": "^4.0.0",
@@ -62,7 +62,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.15",
-    "miolo": "^3.0.0-beta.195",
+    "miolo": "^3.0.0-beta.196",
     "sass-embedded": "^1.99.0"
   },
   "overrides": {

package/template/src/server/db/io/todos/delete.mjs

@@ -1,5 +1,5 @@
 import Joi from "joi"
-import { with_miolo_schema } from "miolo"
+import { with_miolo_input_schema } from "miolo"
 import { opt_int } from "#server/utils/schema.mjs"
 import { db_todo_find } from "./find.mjs"
 
@@ -26,4 +26,4 @@ const todo_delete_schema = Joi.object({
   id: opt_int
 })
 
-export const db_todo_delete = with_miolo_schema(_db_todo_delete, todo_delete_schema)
+export const db_todo_delete = with_miolo_input_schema(_db_todo_delete, todo_delete_schema)

package/template/src/server/db/io/todos/read.mjs

@@ -1,5 +1,5 @@
 import Joi from "joi"
-import { with_miolo_schema } from "miolo"
+import { with_miolo_input_schema } from "miolo"
 import { make_query_filter } from "#server/db/io/filter.mjs"
 import { bool_null, opt_int, opt_str_null } from "#server/utils/schema.mjs"
 
@@ -80,4 +80,4 @@ const todo_read_schema = Joi.object({
   })
 })
 
-export const db_todo_read = with_miolo_schema(_db_todo_read, todo_read_schema)
+export const db_todo_read = with_miolo_input_schema(_db_todo_read, todo_read_schema)

package/template/src/server/db/io/todos/toggle.mjs

@@ -1,5 +1,5 @@
 import Joi from "joi"
-import { with_miolo_schema } from "miolo"
+import { with_miolo_input_schema } from "miolo"
 import { bool_null, opt_int } from "#server/utils/schema.mjs"
 import { db_todo_find } from "./find.mjs"
 import { db_todo_upsave } from "./upsave.mjs"
@@ -34,4 +34,4 @@ const todo_toggle_schema = Joi.object({
   done: bool_null
 })
 
-export const db_todo_toggle = with_miolo_schema(_db_todo_toggle, todo_toggle_schema)
+export const db_todo_toggle = with_miolo_input_schema(_db_todo_toggle, todo_toggle_schema)

package/template/src/server/db/io/todos/upsave.mjs

@@ -1,5 +1,5 @@
 import Joi from "joi"
-import { with_miolo_schema } from "miolo"
+import { with_miolo_input_schema } from "miolo"
 import { bool_null, opt_int, opt_str_null } from "#server/utils/schema.mjs"
 
 async function _db_todo_upsave(ctx, params) {
@@ -29,4 +29,4 @@ const todo_upsave_schema = Joi.object({
   done: bool_null
 })
 
-export const db_todo_upsave = with_miolo_schema(_db_todo_upsave, todo_upsave_schema)
+export const db_todo_upsave = with_miolo_input_schema(_db_todo_upsave, todo_upsave_schema)

package/template/src/server/routes/index.mjs

@@ -1,5 +1,5 @@
 import Joi from "joi"
-import { with_miolo_schema } from "miolo"
+import { with_miolo_input_schema, with_miolo_output_schema } from "miolo"
 import { r_todo_delete, r_todo_toggle_done, r_todo_upsave } from "./todos/mod.mjs"
 
 import { r_todo_find, r_todo_last, r_todo_list } from "./todos/read.mjs"
@@ -32,18 +32,31 @@ export default [
         method: "GET",
         // Passing schema on the route definition
         callback: r_todo_count_last_hours,
-        schema: Joi.object({
-          hours: Joi.number().min(1).max(24)
-        })
+        schema: {
+          input: Joi.object({
+            hours: Joi.number().min(1).max(24)
+          }),
+          output: Joi.object({
+            count: Joi.number()
+          })
+        }
       },
       {
         url: "/todo/fake",
         method: "POST",
         // Wrapping function with the schema
-        callback: with_miolo_schema(
-          r_todo_insert_fake,
+        callback: with_miolo_output_schema(
+          with_miolo_input_schema(
+            r_todo_insert_fake,
+            Joi.object({
+              done: Joi.bool().optional().default(false)
+            })
+          ),
           Joi.object({
-            done: Joi.bool().optional().default(false)
+            ok: Joi.bool(),
+            data: Joi.object({
+              id: Joi.number()
+            })
           })
         ),
         auth