galbe 0.11.0 → 0.12.1

package/bin/res/client.template.ts

@@ -1,4 +1,3 @@
-export type GalbeClientMode = 'response' | 'direct'
 export type GalbeClientConfig = {
   server?: { url?: string }
 }
@@ -7,7 +6,7 @@ export const Kind = Symbol.for('json.string')
 type Json<T> = { T: T }
 
 interface GR<S extends number | 'default' = 'default', B = any, OKS extends number = OKStatusCode> {
-  status: Exclude<S, "default">
+  status: Exclude<S, 'default'>
   ok: S extends OKS ? true : false
   redirected: boolean
   statusText: string
@@ -18,16 +17,16 @@ interface GR<S extends number | 'default' = 'default', B = any, OKS extends numb
     stream?: ST
   ) => B extends Uint8Array
     ? ST extends true
-    ? Promise<AsyncGenerator<Uint8Array, void, unknown>>
-    : B extends Json<infer T>
-    ? Promise<T>
-    : Promise<B>
+      ? Promise<AsyncGenerator<Uint8Array, void, unknown>>
+      : B extends Json<infer T>
+      ? Promise<T>
+      : Promise<B>
     : B extends string
     ? ST extends true
-    ? Promise<AsyncGenerator<string, void, unknown>>
-    : B extends Json<infer T>
-    ? Promise<T>
-    : Promise<B>
+      ? Promise<AsyncGenerator<string, void, unknown>>
+      : B extends Json<infer T>
+      ? Promise<T>
+      : Promise<B>
     : B extends Json<infer T>
     ? Promise<T>
     : Promise<B>
@@ -42,16 +41,32 @@ type PGR<
   O extends number = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226
 > = Promise<GR<S, B, O>>
 
-type RequestOptions<H = any, Q = any, B = any> = {
+type ContentType = 'byteArray' | 'text' | 'json' | 'urlForm' | 'multipart' | 'default'
+type RequestOptions<
+  H = any,
+  Q = any,
+  B extends Partial<Record<ContentType, any>> = Partial<Record<ContentType, any>>,
+  C extends keyof B = keyof B
+> = {
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD'
   headers?: H
   query?: Q
-  body?: B
-  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD'
+  contentType?: C
+  body?: B[C]
 }
 
 const decoder = new TextDecoder()
 const DEFAULT_HEADERS = {
-  'user-agent': 'Galbe//*%(()=>version)()%*/'
+  'user-agent': 'Galbe//*%(()=>version)()%*/',
+}
+
+const formdata = (data: Record<string, string | string[] | Blob>): FormData => {
+  const form = new FormData()
+  for (const [k, v] of Object.entries(data)) {
+    if (Array.isArray(v)) for (const v2 of v) form.append(String(k), String(v2))
+    else form.append(String(k), String(v))
+  }
+  return form
 }
 
 // Typescript types
@@ -62,27 +77,23 @@ Object.entries(types).map(([tk, t])=>{
 %*/
 
 export default class GalbeClient {
-  config?: GalbeClientConfig
   /*%
   Object.entries(routes).map(([method, list])=>{
     return`${method} = {\n${list.map( r => {
       let p = Object.entries(r.params)
       let schemas = Object.keys(r.schemas).length ?
-        `<${r.schemas.headers??'any'},${r.schemas.query??'any'},${r.schemas.body??'any'}>`: 
+        `<${r.schemas.headers??'any'},${r.schemas.query??'any'},${r.schemas.body??'any'},CT>`: 
         ''
       let oks = Object.keys(r.schemas?.response||{}).filter(s=>s>=200&&s<300)
       let responses = Object.keys(r.schemas?.response||{}).length ?
         `${Object.entries(r.schemas.response).filter(([s,_])=>s!=='"default"').map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).filter(s=>s!=='"default"').join('|')}>,${'"default"' in r.schemas.response ? r.schemas.response['"default"'] : 'any'}${oks?.length?`,${oks.join('|')}`:''}>`: 
         `PGR<HttpStatusCode,any${oks?.length?`,${oks.join('|')}`:',any'}>`
-      return `  '${r.path}':(${p.length?p.map(([k,v])=>`${k}:${v.type}`).join(',')+', ':''}options:RequestOptions${schemas}={})=>this.fetch(\`${r.pathT}\`,{...options,method:'${r.method.toUpperCase()}'}) as ${responses}`
+      return `  '${r.path}':<CT extends ${r.contentTypes}>(${p.length?p.map(([k,v])=>`${k}:${v.type}`).join(',')+', ':''}options:RequestOptions${schemas}={})=>this.fetch(\`${r.pathT}\`,{...options,method:'${r.method.toUpperCase()}'}) as ${responses}`
     }).join(',\n')}\n}`
   }).join('\n')
   %*/
 
-  constructor(config?: GalbeClientConfig) {
-    //@ts-ignore
-    this.config = { mode: 'response', ...config }
-  }
+  constructor(private readonly config?: GalbeClientConfig) {}
 
   async fetch(path: string, options: RequestOptions) {
     let url = `${this?.config?.server?.url ?? ''}${path}`
@@ -90,8 +101,23 @@ export default class GalbeClient {
     url = `${url}?${params.toString()}`
     let res = await fetch(url, {
       method: options?.method || 'GET',
-      headers: { ...DEFAULT_HEADERS, ...(options?.headers || {}) },
-      ...(options?.body ? { body: JSON.stringify(options.body) } : {})
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...(options?.contentType && ['byteArray', 'text', 'json', 'urlForm'].includes(options.contentType)
+          ? {
+              'content-type': {
+                byteArray: 'application/octet-stream',
+                text: 'text/plain',
+                json: 'application/json',
+                urlForm: 'application/x-www-form-urlencoded',
+              }[options.contentType],
+            }
+          : {}),
+        ...(options?.headers || {}),
+      },
+      ...(options?.body
+        ? { body: options?.contentType === 'multipart' ? formdata(options?.body) : JSON.stringify(options.body) }
+        : {}),
     })
     return {
       headers: res.headers,
@@ -147,7 +173,7 @@ export default class GalbeClient {
           }
         }
         return res.body
-      }
+      },
     }
   }
 
@@ -157,7 +183,7 @@ export default class GalbeClient {
     return list.filter(r=>r.alias).map(r => {
       let p = Object.entries(r.params)
       let schemas = Object.keys(r.schemas).length ?
-        `<${r.schemas.headers??'any'},${r.schemas.query??'any'},${r.schemas.body??'any'}>`: 
+        `<${r.schemas.headers??'any'},${r.schemas.query??'any'},${r.schemas.body??'any'},CT>`: 
         ''
       let oks = Object.keys(r.schemas?.response||{}).filter(s=>s>=200&&s<300)
       let responses = Object.keys(r.schemas?.response||{}).length ?
@@ -167,7 +193,7 @@ export default class GalbeClient {
       let description = r.description ? `   * ${r.description.replace(/\n/g,'\n   * ')}` : ''
       let params = Object.entries(r.schema.params || {}).map( ([k,v])=>`\n   * @param ${k} - ${v.description?.replace(/\n/g,'\n     ')}` ).join('')
       let query = Object.entries(r.schema.query || {}).map( ([k,v])=>`\n   * @param options.query.${k} - ${v.description?.replace(/\n/g,'\n     ')}` ).join('')
-      return `/**\n${summary}${description}\n   *${params}${query}\n   *\/\n  ${r.alias}(${p.length ? p.map(([k,v])=>`${k}: ${v.type}`).join(', ')+', ':''}options: RequestOptions${schemas} = {}){return this.fetch(\`${r.pathT}\`, {...options, method: '${r.method.toUpperCase()}'}) as ${responses}}\n`
+      return `/**\n${summary}${description}\n   *${params}${query}\n   *\/\n  ${r.alias}<CT extends ${r.contentTypes}>(${p.length ? p.map(([k,v])=>`${k}: ${v.type}`).join(', ')+', ':''}options: RequestOptions${schemas} = {}){return this.fetch(\`${r.pathT}\`, {...options, method: '${r.method.toUpperCase()}'}) as ${responses}}\n`
     }).join('  ')
   })
   %*/

package/bin/util.ts

@@ -15,14 +15,14 @@ export const fmtVal = (v: any) => {
   if (typeof v === 'number') return `\x1b[36m${v}\x1b[0m`
   return v
 }
-export const fmtList = (l: any) => `[${l.map((v:any) => fmtVal(v)).join(', ')}]`
+export const fmtList = (l: any) => `[${l.map((v: any) => fmtVal(v)).join(', ')}]`
 export const fmtInterval = (a: any, b: any) => `[${fmtVal(a)}-${fmtVal(b)}]`
 
 export const silentExec = async (fn: () => any) => {
   let consoleMock = Object.fromEntries(
     Object.entries(console)
       .filter(([_, v]) => typeof v === 'function')
-      .map(([k, _]) => [k, () => { }])
+      .map(([k, _]) => [k, () => {}])
   )
   const _console = console
   const _processStdoutWrite = process.stdout.write
@@ -30,9 +30,9 @@ export const silentExec = async (fn: () => any) => {
   //@ts-ignore
   global.console = consoleMock
   //@ts-ignore
-  process.stdout.write = function () { }
+  process.stdout.write = function () {}
   //@ts-ignore
-  process.stderr.write = function () { }
+  process.stderr.write = function () {}
   const r = await fn()
   global.console = _console
   process.stdout.write = _processStdoutWrite
@@ -50,7 +50,7 @@ export const watchDir = async (
   let watcher = watch(path, {
     persistent: false,
     ignored: options?.ignore,
-    ignoreInitial: true
+    ignoreInitial: true,
   })
   watcher.on('all', async (eventType, filename) => {
     if (filename.match(WATCH_IGNORE)) return
@@ -90,11 +90,31 @@ export const instanciateRoutes = async (g: Galbe) => {
       console.log(`\x1b\[0;31m    Error:\x1b[0m`)
       console.log(errors?.[fp])
     }
-    console.log("")
+    console.log('')
   }
   console.log('\x1b[1;30m\x1b[32mdone\x1b[0m\n')
 }
 
+export function abbreviateVar(input: string): string {
+  if (!input) return ''
+  const normalized = input
+    .replace(/[_\-\s]+/g, ' ')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
+
+  const tokens = normalized
+    .trim()
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter(Boolean)
+
+  if (tokens.length === 0) return ''
+
+  return tokens
+    .map(t => t[0])
+    .join('')
+    .toLowerCase()
+}
+
 export const killPort = async (port: number) => {
   let getProcCmd: string[], killCmd: (port: string) => string[]
 
@@ -172,5 +192,5 @@ export const HttpStatus = {
   504: 'Gateway Timeout',
   505: 'HTTP Version Not Supported',
   507: 'Insufficient Storage',
-  511: 'Network Authentication Required'
+  511: 'Network Authentication Required',
 }

package/docs/context.md

@@ -49,7 +49,7 @@ galbe.get('/test', ctx => console.log(ctx.query))
 
 The body payload of the incoming request. The body type is determined based on the following rules:
 
-If no [Schema](schemas.md) is defined, Galbe will parse the body type according to the `Content-Type` header:
+If no [Schema](schemas.md) is defined, Galbe will parse the body type according to the `content-type` header:
 
 - `text/.*`: string
 - `application/json`: object

package/docs/schemas.md

@@ -174,42 +174,75 @@ const schema = {
 
 <!-- prettier-ignore -->
 ```ts
-body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STArray | STMultipartForm | STUrlForm | STStream
+body: {
+  byteArray?: STByteArray | STStream
+  text?: STString | STLiteral | STBoolean | STNumber | STInteger | STUnion | STStream
+  json?: STJson | STObject | STBoolean | STInteger | STNumber | STString | STArray | STUnion
+  urlForm?: STObject | STStream | STUnion
+  multipart?: STMultipartForm | STStream | STUnion
+  default?: STString | STByteArray | STStream | STAny
+}
 ```
 
 Defines the request body Schema type based on content type.
 
-#### object
+#### Byte Array
 
-Defines an `application/json` request body.
+Defines an `application/octet-stream` request body.
 
 ```ts
-const jsonBody = $T.object({
-  name: $T.string(),
-  age: $T.integer({ min: 0 })
-})
+const body = {
+  byteArray: $T.byteArray()
+}
 ```
 
-#### multipartForm
+#### Text
 
-Defines a `multipart/form-data` request body.
+Defines an `text/*` request body.
 
 ```ts
-const multipartBody = $T.multipartForm({
-  name: $T.string(),
-  age: $T.integer({ min: 0 })
-})
+const body = {
+  text: $T.string()
+}
+```
+
+#### JSON
+
+Defines an `application/json` request body.
+
+```ts
+const body = {
+  json: $T.object({
+    name: $T.string(),
+    age: $T.integer({ min: 0 })
+  })
+}
 ```
 
-#### urlForm
+#### URL Form
 
 Defines an `application/x-www-form-urlencoded` request body.
 
 ```ts
-const urlBody = $T.urlForm({
-  name: $T.string(),
-  age: $T.integer({ min: 0 })
-})
+const body = { 
+  urlForm: {$T.object({
+    name: $T.string(),
+    age: $T.integer({ min: 0 })
+  })
+}
+```
+
+#### Multipart Form
+
+Defines a `multipart/form-data` request body.
+
+```ts
+const body = {
+  multipart: $T.multipartForm({
+    name: $T.string(),
+    age: $T.integer({ min: 0 })
+  })
+}
 ```
 
 #### stream
@@ -225,10 +258,12 @@ Let's consider a `multipart/form-data` body request that has two properties: `us
 galbe.post(
   'user/create',
   {
-    body: $T.multipartForm({
-      username: $T.string(),
-      heavyImageFile: $T.byteArray()
-    })
+    body: {
+      multipart: $T.multipartForm({
+        username: $T.string(),
+        heavyImageFile: $T.byteArray()
+      })
+    }
   },
   ctx => {
     // At that point, the full body request has been processed
@@ -247,10 +282,12 @@ A better approach would consist in leveraging `STStream` wrapper to implement ea
 galbe.post(
   'user/create',
   {
-    body: $T.stream($T.multipartForm({
-      username: $T.string(),
-      heavyImageFile: $T.byteArray()
-    }))
+    body: {
+      multipart: $T.stream($T.multipartForm({
+        username: $T.string(),
+        heavyImageFile: $T.byteArray()
+      }))
+    }
   },
   async ctx => {
     // At that point, the body has not been processed yet.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",

package/src/extras/spec/openapi.serializer.ts

@@ -1,7 +1,16 @@
-import type { STArray, STJson, STLiteral, STObject, STProps, STSchema, STUnion } from '../../../src/schema'
+import type {
+  STArray,
+  STIntersection,
+  STJson,
+  STLiteral,
+  STObject,
+  STProps,
+  STSchema,
+  STUnion,
+} from '../../../src/schema'
 
 import { Galbe } from '../../../src'
-import { walkRoutes, HttpStatus } from '../../../src/util'
+import { walkRoutes, HttpStatus, inferContentType } from '../../../src/util'
 import { Kind, Optional } from '../../../src/schema'
 
 import { OpenAPIV3 } from 'openapi-types'
@@ -12,10 +21,10 @@ const schemaToMedia = ({ type, format, isJson }: SchemaType) =>
   isJson || (type && ['object', 'number', 'boolean', 'array'].includes(type))
     ? 'application/json'
     : format === 'byte'
-      ? 'application/octet-stream'
-      : type === 'string'
-        ? 'text/plain'
-        : '*/*'
+    ? 'application/octet-stream'
+    : type === 'string'
+    ? 'text/plain'
+    : '*/*'
 
 export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<OpenAPIV3.Document> => {
   let paths: any = {}
@@ -24,7 +33,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
     schemas: {},
     parameters: {},
     requestBodies: {},
-    responses: {}
+    responses: {},
   }
 
   const schemaToOpenapi = (
@@ -54,7 +63,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
 
     if (kind === 'null') {
       s = {
-        anyOf: ['null']
+        anyOf: ['null'],
       }
     } else if (kind === 'boolean') s = { type: 'boolean' }
     else if (kind === 'byteArray') s = { type: 'string', format: 'byte' }
@@ -64,7 +73,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         ...(exclusiveMinimum ? { exclusiveMinimum } : {}),
         ...(exclusiveMaximum ? { exclusiveMaximum } : {}),
         ...(minimum ? { minimum } : {}),
-        ...(maximum ? { maximum } : {})
+        ...(maximum ? { maximum } : {}),
       }
     else if (kind === 'integer')
       s = {
@@ -72,14 +81,14 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         ...(exclusiveMinimum ? { exclusiveMinimum } : {}),
         ...(exclusiveMaximum ? { exclusiveMaximum } : {}),
         ...(minimum ? { minimum } : {}),
-        ...(maximum ? { maximum } : {})
+        ...(maximum ? { maximum } : {}),
       }
     else if (kind === 'string')
       s = {
         type: 'string',
         ...(pattern ? { pattern } : {}),
         ...(minLength ? { minLength } : {}),
-        ...(maxLength ? { maxLength } : {})
+        ...(maxLength ? { maxLength } : {}),
       }
     else if (kind === 'any') s = { type: 'string' }
     else if (kind === 'literal') {
@@ -91,7 +100,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         items: schemaToOpenapi((schema as STArray).items).schema,
         ...(minItems ? { minItems } : {}),
         ...(maxItems ? { maxItems } : {}),
-        ...(uniqueItems ? { uniqueItems } : {})
+        ...(uniqueItems ? { uniqueItems } : {}),
       }
     } else if (kind === 'object') {
       let props = (schema as STObject).props || {}
@@ -101,7 +110,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       s = {
         type: 'object',
         properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
-        ...(required.length ? { required } : {})
+        ...(required.length ? { required } : {}),
       }
     } else if (kind === 'json') {
       let props = ((schema as STJson).props || {}) as STProps
@@ -115,13 +124,13 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         type: type,
         ...(type === 'object'
           ? {
-            properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
-            ...(required.length ? { required } : {})
-          }
-          : {})
+              properties: Object.fromEntries(Object.entries(props).map(([k, v]) => [k, schemaToOpenapi(v).schema])),
+              ...(required.length ? { required } : {}),
+            }
+          : {}),
       }
     } else if (kind === 'union') {
-      let anyOf = (schema as STUnion).anyOf
+      let anyOf: STSchema[] = (schema as STUnion).anyOf
       let nullable = anyOf.some(s => s[Kind] === 'null')
       anyOf = anyOf.filter(s => s[Kind] !== 'null')
 
@@ -131,12 +140,23 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         s = schemaToOpenapi(anyOf[0]).schema
       } else if (anyOf.length > 1) {
         s = {
-          anyOf: anyOf.map(s => schemaToOpenapi(s).schema)
+          anyOf: anyOf.map(e => schemaToOpenapi(e).schema),
         }
       }
 
       //@ts-ignore
       if (nullable) s.nullable = nullable
+    } else if (kind === 'intersection') {
+      let allOf: STSchema[] = (schema as STIntersection).allOf
+      if (allOf.length === 0) {
+        s = {}
+      } else if (allOf.length === 1) {
+        s = schemaToOpenapi(allOf[0]).schema
+      } else if (allOf.length > 1) {
+        s = {
+          allOf: allOf.map(s => schemaToOpenapi(s).schema),
+        }
+      }
     }
 
     s = { title: schema.title, description: schema.description, ...s }
@@ -168,7 +188,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       description: param?.description,
       required: kind === 'path' ? true : !param[Optional] || undefined,
       deprecated: param.deprecated,
-      schema
+      schema,
     }
     if (components.parameters && param.id) components.parameters[param.id] = p
     return p
@@ -178,18 +198,17 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
     (routes, c) => ({ ...routes, ...c.routes }),
     {} as Record<string, Record<string, Record<string, any>>>
   )
-  let metaStatic = Object.fromEntries(Object.entries(metaRoutes || {}).filter((([_, d]) => d?.static)))
+  let metaStatic = Object.fromEntries(Object.entries(metaRoutes || {}).filter(([_, d]) => d?.static))
 
   walkRoutes(g.router.routes, r => {
     let meta = metaRoutes?.[r.path]?.[r.method]
-    if (r.static?.root)
-      meta = metaStatic[r.static?.root]?.static
+    if (r.static?.root) meta = metaStatic[r.static?.root]?.static
     if (meta?.hide) return
     let path = r.path.replaceAll(/:([^\/]+)/g, '{$1}')
     if (!(path in paths)) paths[path] = {}
     let tags = [
       ...(meta?.tags?.split(' ')?.map((t: string) => t.trim()) || []),
-      ...(typeof meta?.tag === 'string' ? [meta?.tag] : meta?.tag || [])
+      ...(typeof meta?.tag === 'string' ? [meta?.tag] : meta?.tag || []),
     ]
     let security: Record<string, any> = []
 
@@ -201,52 +220,62 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       : []
     let headerParam = r.schema?.headers
       ? Object.entries(r.schema?.headers as Record<string, STSchema>)
-        .map(([k, v]) => {
-          let p = parseParam(k, v, 'header')
-          if (k.match(/authorization/i)) {
-            // TODO: handle other auth methods
-            if (v.pattern && v?.pattern?.toString() === '/^Bearer /') {
-              security.push({ bearerAuth: [] })
-              components.securitySchemes = { bearerAuth: { type: 'http', scheme: 'bearer' } }
-              return null
+          .map(([k, v]) => {
+            let p = parseParam(k, v, 'header')
+            if (k.match(/authorization/i)) {
+              // TODO: handle other auth methods
+              if (v.pattern && v?.pattern?.toString() === '/^Bearer /') {
+                security.push({ bearerAuth: [] })
+                components.securitySchemes = { bearerAuth: { type: 'http', scheme: 'bearer' } }
+                return null
+              }
             }
-          }
-          return p
-        })
-        .filter(p => p)
+            return p
+          })
+          .filter(p => p)
       : []
     // TODO cookieParam
     let parameters = [...pathParam, ...queryParam, ...headerParam]
 
     let requestBody
     if (r.schema.body) {
-      let { schema, isJson } = schemaToOpenapi(r.schema.body)
-      let { type, format } = resolveRef(schema)
-      let media = schemaToMedia({ type, format, isJson } as SchemaType)
+      let description: string | undefined
+      let conflictDescription = false
+      let required = false
+      let content = Object.fromEntries(
+        Object.entries(r.schema.body).map(([bodyType, schema]) => {
+          const s = schema.description
+          const isDefined = typeof s === 'string' && s !== ''
+          if (s?.[Optional] === false) required = true
+          if (isDefined) {
+            if (description === undefined) {
+              description = s
+            } else if (description !== s) {
+              conflictDescription = true
+            }
+          }
+          description = conflictDescription ? undefined : description ?? undefined
+          return [inferContentType(bodyType), { schema: schemaToOpenapi(schema).schema }]
+        })
+      )
       requestBody = {
-        description: r.schema.body.description,
-        required: !r.schema.body[Optional],
-        content: {
-          [media]: { schema }
-        }
-      }
-      if (r.schema.body.id && components.requestBodies) {
-        components.requestBodies[r.schema.body.id] = requestBody
-        requestBody = { $ref: `#/components/requestBodies/${r.schema.body.id}` }
+        description,
+        required,
+        content,
       }
     }
     let responses
     if (r.schema.response && Object.keys(r.schema.response).length) {
       responses = Object.fromEntries(
         Object.entries(r.schema.response).map(([status, v]) => {
-          if(!v) return []
+          if (!v) return []
           let s = status as keyof typeof HttpStatus | 'default'
           let { schema, isJson } = schemaToOpenapi(v)
           let { type, format } = resolveRef(schema)
           let media = schemaToMedia({ type, format, isJson } as SchemaType)
           let response: OpenAPIV3.ResponseObject = {
             description: v.description || HttpStatus[s as keyof typeof HttpStatus] || 'Response',
-            content: { [media]: { schema: schema } }
+            content: { [media]: { schema: schema } },
           }
           if (components.responses && r.schema.response?.[s]?.id) {
             components.responses[r.schema.response?.[s]?.id as string] = response
@@ -258,12 +287,10 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       )
     } else {
       responses = {
-        default: { description: HttpStatus[200] }
+        default: { description: HttpStatus[200] },
       }
     }
     let summary = meta?.head.match(/^([^\n]+)/)?.[1]
-    console.log('#', r.method, r.path)
-    console.log(r.schema.body)
     paths[path][r.method] = {
       tags: tags.length ? tags : undefined,
       summary: summary,
@@ -272,7 +299,7 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       requestBody,
       responses,
       ...(security.length ? { security } : {}),
-      deprecated: meta?.deprecated ? true : undefined
+      deprecated: meta?.deprecated ? true : undefined,
     }
   })
 
@@ -285,9 +312,9 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
     openapi: version,
     info: {
       title: 'Galbe app',
-      version: '0.1.0'
+      version: '0.1.0',
     },
     paths,
-    components: Object.keys(components)?.length ? components : undefined
+    components: Object.keys(components)?.length ? components : undefined,
   }
 }