galbe 0.7.0 → 0.9.0

package/bin/commands/build.ts

@@ -3,34 +3,42 @@ import { $ } from 'bun'
 import { Command, Option } from 'commander'
 import { resolve, relative, dirname } from 'path'
 import { tmpdir } from 'os'
-import { mkdir, rm } from 'fs/promises'
+import { mkdir, rm, exists } from 'fs/promises'
 
 import { CWD, fmtVal, silentExec } from '../util'
 import { Galbe } from '../../src'
-import { defineRoutes } from '../../src/routes'
+import { defineRoutes, GalbeProxy } from '../../src/routes'
 import { BuildConfig } from 'bun'
 
-const createBuildIndex = async (indexPath: string, g: Galbe) => {
-  const buildId = crypto.randomUUID()
+const createBuildIndex = async (indexPath: string, g: Galbe, buildId: string) => {
   const buildPath = resolve(tmpdir(), buildId)
-  const routes = new Set<string>()
+  const routes = new Map<string, { filepath: string, static?: { path: string, root: string } }>()
   let errors: any[] = []
-  await defineRoutes({ routes: g?.config?.routes }, g, ({ type, error, filepath }) => {
+  // Create GalbeProxy here
+  // use it to define routes
+  const proxy = new GalbeProxy(g, ({ type, error, filepath, route }) => {
     if (!filepath) return
-    routes.add(filepath)
+    routes.set(filepath, { filepath, static: route?.static })
     if (type === 'error') errors.push(error)
   })
+  await defineRoutes({ routes: g?.config?.routes }, proxy)
+  // call init on it for plugin initialization
+  await proxy.init()
+
   if (errors.length) throw errors
   await mkdir(buildPath, { recursive: true })
-  await Bun.write(
-    resolve(buildPath, 'index.ts'),
-    `import galbe from '${relative(buildPath, indexPath)}';
-${[...routes].map((r, idx) => `import _${idx} from '${relative(buildPath, r)}'`).join(';\n')}
-galbe.meta = ${JSON.stringify(g.meta)};
-${[...routes].map((_, idx) => `_${idx}(galbe)`).join(';\n')}
-galbe.listen();
-`
-  )
+
+  let buildIndex =
+    `import galbe from '${relative(buildPath, indexPath)}';\n` +
+    `${[...routes.values()].map((r, idx) => `import _${idx} from '${relative(buildPath, r.filepath)}'`).join(';\n')}\n` +
+    `Bun.env.BUN_ENV = 'production';\n` +
+    `Bun.env.GALBE_BUILD = '${buildId}';\n` +
+    `galbe.meta = ${JSON.stringify(g.meta)};\n` +
+    `${[...routes].map((_, idx) => `_${idx}(galbe)`).join(';\n')};\n` +
+    `galbe.listen();\n`
+
+  await Bun.write(resolve(buildPath, 'index.ts'), buildIndex)
+
   return resolve(buildPath, 'index.ts')
 }
 
@@ -44,10 +52,18 @@ export default (cmd: Command) => {
     .action(async (index, props) => {
       const { out, compile, config } = props
 
+      const buildID = crypto.randomUUID()
+      const outPath = resolve(CWD, out)
+
+      Bun.env.GALBE_BUILD = buildID
+      Bun.env.GALBE_BUILD_OUT = outPath
+
       const bunfig = config ? (await import(resolve(CWD, config)))?.default || {} : {}
 
+      if(await exists(outPath)) await rm(outPath, { recursive: true })
+
       let error = null
-      process.stdout.write('📦 \x1b[1;30mBuilding \x1b[36mGalbe\x1b[0m\x1b[1;30m app\x1b[0m')
+      Bun.write(Bun.stdout, '📦 \x1b[1;30mBuilding \x1b[36mGalbe\x1b[0m\x1b[1;30m app\x1b[0m')
       let g: Galbe = await silentExec(async () => {
         try {
           const g = (await import(resolve(CWD, index))).default
@@ -63,7 +79,7 @@ export default (cmd: Command) => {
       }
       let buildIndex: string = ''
       try {
-        buildIndex = await createBuildIndex(index, g)
+        buildIndex = await createBuildIndex(index, g, buildID)
       } catch (errors) {
         console.log(`\nerror: build errors`)
         for (let error of errors) console.log(error)
@@ -75,24 +91,25 @@ export default (cmd: Command) => {
       }
 
       const buildConfig: BuildConfig = {
-        publicPath: `${resolve(CWD, out)}/`,
+        publicPath: `${outPath}/`,
         ...Object.fromEntries(Object.entries(bunfig).filter(([k, v]) => v)),
         entrypoints: [buildIndex],
-        outdir: resolve(CWD, out),
+        outdir: outPath,
         sourcemap: 'external',
-        target: 'bun'
+        target: 'bun',
       }
 
-      await rm(resolve(CWD, out), { recursive: true })
-
       let bo = await Bun.build(buildConfig)
-      if (bo.success) process.stdout.write(' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      if (bo.success) Bun.write(Bun.stdout, ' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
       else {
         console.log(`\nerror: build errors`)
         console.log(...bo.logs)
       }
-      if (compile) await $`bun build --compile ${resolve(CWD, out, 'index.js')} --outfile ${resolve(CWD, out, 'app')}`
+      if (compile) {
+        await $`bun build --compile ${resolve(CWD, out, 'index.js')} --outfile ${outPath}/bin`
+      }
 
       await rm(dirname(buildIndex), { recursive: true })
+      process.exit(0)
     })
 }

package/bin/commands/dev.ts

@@ -20,7 +20,8 @@ export default (cmd: Command) => {
         })
         .default(null, fmtVal(defaultPort))
     )
-    .addOption(new Option('-w, --watch', 'watch file changes').default(false, fmtVal(false)))
+    .addOption(new Option('-w, --watch <dir>', 'watch file changes').default(false, fmtVal(false)))
+    .addOption(new Option('-wi, --watchignore <regexp>', 'ignore file changes').default(false, fmtVal(false)))
     .addOption(new Option('-nc, --noclear', "don't clear on file changes").default(false, fmtVal(false)))
     .addOption(
       new Option('-f, --force', 'kills any process running on defined port before strating the server').default(
@@ -29,7 +30,8 @@ export default (cmd: Command) => {
       )
     )
     .action(async (index, props) => {
-      const { port, watch, noclear, force } = props
+      const { port, watch, watchignore, noclear, force } = props
+      let watch_dir = typeof watch === 'string' ? watch : CWD
       const clear = !noclear
       const indexPath = resolve(CWD, index)
       let g: Galbe
@@ -38,9 +40,9 @@ export default (cmd: Command) => {
 
       if (force) await killPort(port || 3000)
 
-      if (watch) {
+      if (!!watch) {
         await watchDir(
-          CWD,
+          watch_dir,
           async () => {
             g.stop()
             if (clear) await $`clear`
@@ -49,11 +51,11 @@ export default (cmd: Command) => {
             await instanciateRoutes(g)
             await g.listen(port)
           },
-          { ignore: /node_modules/ }
+          { ignore: watchignore ? new RegExp(watchignore) : /node_modules/ }
         )
       }
 
-      if (watch && clear) await $`clear`
+      if (!!watch && clear) await $`clear`
       g = (await import(indexPath)).default
       await instanciateRoutes(g)
       await g.listen(port)

package/bin/commands/generate/client.ts

@@ -6,7 +6,7 @@ import { resolve, extname } from 'path'
 import { rm } from 'fs/promises'
 import { transformSync } from '@swc/core'
 import { CWD, fmtList, instanciateRoutes, silentExec } from '../../util'
-import { $T, Galbe, GalbeCLICommand, Method, Route } from '../../../src'
+import { $T, Galbe, GalbeCLICommand, Method, Route, STResponse } from '../../../src'
 import { walkRoutes } from '../../../src/util'
 import { schemaToTypeStr, Optional, STSchema } from '../../../src/schema'
 
@@ -36,10 +36,10 @@ export default (cmd: Command) => {
       let pckg: any = {}
       try {
         pckg = await Bun.file(resolve(CWD, 'package.json')).json()
-      } catch (e) {}
+      } catch (e) { }
 
       let error = null
-      process.stdout.write('💻 \x1b[1;30mBuilding \x1b[36mGalbe\x1b[0m\x1b[1;30m client\x1b[0m')
+      Bun.write(Bun.stdout, '💻 \x1b[1;30mBuilding \x1b[36mGalbe\x1b[0m\x1b[1;30m client\x1b[0m')
       let g: Galbe = await silentExec(async () => {
         try {
           const g = (await import(resolve(CWD, index))).default
@@ -65,6 +65,7 @@ export default (cmd: Command) => {
         options: [],
         head: []
       }
+      const types: Record<string, STResponse> = {}
       let commands: GalbeCLICommand[] = []
       const metaRoutes = g.meta?.reduce(
         (routes, c) => ({ ...routes, ...c.routes }),
@@ -73,9 +74,13 @@ export default (cmd: Command) => {
 
       walkRoutes(g.router.routes, r => {
         let meta = metaRoutes?.[r.path]?.[r.method]
+        let [_, summary, description] = meta?.head?.match(/^([^\n]*)\n\n(.*)/) || []
+        if(!summary) description = meta?.head
         let route = {
           ...r,
           ...(meta?.operationId ? { alias: meta?.operationId } : {}),
+          ...(summary ? { summary } : {}),
+          ...(description ? { description } : {}),
           pathT: r.path.replaceAll(/:([^\/]+)/g, '${$1}'),
           params:
             Object.fromEntries(
@@ -84,11 +89,11 @@ export default (cmd: Command) => {
                 {
                   ...(r.schema?.params?.[m?.[1]]
                     ? {
-                        type: schemaToTypeStr(r.schema.params[m[1]]),
-                        ...(r.schema.params[m[1]]?.description
-                          ? { description: r.schema.params[m[1]].description as string }
-                          : {})
-                      }
+                      type: schemaToTypeStr(r.schema.params[m[1]]),
+                      ...(r.schema.params[m[1]]?.description
+                        ? { description: r.schema.params[m[1]].description as string }
+                        : {})
+                    }
                     : { type: 'string' })
                 }
               ])
@@ -99,18 +104,22 @@ export default (cmd: Command) => {
             ...(r.schema.body ? { body: schemaToTypeStr(r.schema.body) } : {}),
             ...(r.schema.response
               ? {
-                  response: Object.fromEntries(
-                    Object.entries(r.schema.response).map(([k, v]) => [k === 'default' ? 200 : k, schemaToTypeStr(v)])
-                  )
-                }
+                response: Object.fromEntries(
+                  Object.entries(r.schema.response).map(([k, v]) => [k === 'default' ? '"default"' : k, schemaToTypeStr(v as STSchema)])
+                )
+              }
               : {})
           }
         }
+        Object.values(r.schema.response || {}).filter(s => s?.id).forEach(s => {
+          //@ts-ignore
+          types[s.id] = schemaToTypeStr(s)
+        })
         routes[r.method.toLocaleLowerCase()].push(route)
         if (target === 'cli' && meta?.operationId)
           commands.push({
             name: meta.operationId,
-            description: meta.head,
+            description: route.summary || route.description,
             route,
             arguments:
               Object.entries((route?.params || {}) as Record<string, { type: string; description?: string }>)?.map(
@@ -144,7 +153,8 @@ export default (cmd: Command) => {
           const sandbox = {
             console,
             version: pckg?.version || '0.1.0',
-            routes
+            routes,
+            types,
           }
           createContext(sandbox)
           let res = script.runInNewContext(sandbox)
@@ -195,6 +205,7 @@ export default (cmd: Command) => {
         await rm(resolve(CWD, '.galbe'), { recursive: true })
       }
 
-      process.stdout.write(' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      Bun.write(Bun.stdout, ' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      process.exit(0)
     })
 }

package/bin/commands/generate/code/openapi.parser.ts

@@ -68,6 +68,13 @@ const orderDeps = (deps: Record<string, SchemaEntry>) => {
   }
   return Object.fromEntries([...l].map(k => [k, deps[k]]))
 }
+const serialize = (obj: any) => {
+  return JSON.stringify(obj, (k, value) => {
+    if (k === 'pattern' && value) return `/${value}/`
+    return value
+  }).replace(/"\/(.*)\/([gimsuy]*)"/g, '/$1/$2');
+}
+
 const writeCodeFile = async (path: string, content: string, target: 'js' | 'ts') => {
   if (target === 'js') {
     content = transformSync(content, {
@@ -88,7 +95,9 @@ const parseOapiSchema = (
   details: { id?: string; title?: string; description?: string } = {},
   extra?: { media?: string }
 ): string => {
-  if (!os) return `$T.any()`
+  if (!os) {
+    return `$T.any(${details && Object.keys(details).length ? JSON.stringify(details) : ''})`
+  }
   //@ts-ignore
   if (os?.$ref) return `%ref:${os.$ref}%`
   os = os as OpenAPIV3.SchemaObject
@@ -106,11 +115,12 @@ const parseOapiSchema = (
   } = {
     ...details,
     title: os.title,
-    description: os.description
+    description: details.description || os.description
   }
+  if(!os?.type) return `$T.any(${details && Object.keys(details).length ? JSON.stringify(details) : ''})`
   let resp = ''
   let hasOptions = Object.values(options).some(v => !!v)
-  let optArg = hasOptions ? `, ${JSON.stringify(options)}` : ''
+  let optArg = hasOptions ? serialize(options) : ''
   let anyOf = os.oneOf || os.anyOf || os.allOf
   let required = os.required
   let nullable = os.nullable
@@ -118,11 +128,11 @@ const parseOapiSchema = (
   if (anyOf?.length) {
     if (anyOf.length === 1) resp = parseOapiSchema(anyOf[0] as OpenAPIV3.SchemaObject, details, extra)
     else {
-      resp = `$T.union([${anyOf.map(s => parseOapiSchema(s as OpenAPIV3.SchemaObject)).join(',')}], ${JSON.stringify(
+      resp = `$T.union([${anyOf.map(s => parseOapiSchema(s as OpenAPIV3.SchemaObject)).join(',')}], ${serialize(
         options
       )})`
     }
-  } else if (os.type === 'boolean') resp = `$T.boolean(${hasOptions ? JSON.stringify(options) : ''})`
+  } else if (os.type === 'boolean') resp = `$T.boolean(${hasOptions ? serialize(options) : ''})`
   else if (os.type === 'number') {
     let { max, min, exclusiveMax, exclusiveMin } = {
       max: os.maximum !== undefined && !os.exclusiveMaximum ? os.maximum : undefined,
@@ -132,7 +142,7 @@ const parseOapiSchema = (
     }
     options = { ...options, min, max, exclusiveMax, exclusiveMin }
     hasOptions = Object.values(options).some(v => !!v)
-    resp = `$T.number(${hasOptions ? JSON.stringify(options) : ''})`
+    resp = `$T.number(${hasOptions ? serialize(options) : ''})`
   } else if (os.type === 'integer') {
     let max = os.maximum !== undefined && !os.exclusiveMaximum ? os.maximum : undefined
     let min = os.minimum !== undefined && !os.exclusiveMinimum ? os.minimum : undefined
@@ -140,38 +150,35 @@ const parseOapiSchema = (
     let exclusiveMin = os.minimum !== undefined && os.exclusiveMinimum ? os.minimum : undefined
     options = { ...options, min, max, exclusiveMax, exclusiveMin }
     hasOptions = Object.values(options).some(v => !!v)
-    resp = `$T.integer(${hasOptions ? JSON.stringify(options) : ''})`
+    resp = `$T.integer(${hasOptions ? serialize(options) : ''})`
   } else if (os.type === 'string') {
-    if (os.format === 'binary') resp = `$T.byteArray(${hasOptions ? JSON.stringify(options) : ''})`
+    if (os.format === 'binary') resp = `$T.byteArray(${hasOptions ? serialize(options) : ''})`
     else {
       let minLength = os.minLength
       let maxLength = os.maxLength
       let pattern = os.pattern
       options = { ...options, minLength, maxLength, pattern }
       hasOptions = Object.values(options).some(v => !!v)
-      resp = `$T.string(${hasOptions ? JSON.stringify(options) : ''})`
+      resp = `$T.string(${hasOptions ? serialize(options) : ''})`
     }
   } else if (os.type === 'array') {
     let minItems = os.minItems
     let maxItems = os.maxItems
     let unique = os.uniqueItems
     options = { ...options, minItems, maxItems, unique }
-    resp = `$T.array(${parseOapiSchema(os?.items)}${optArg})`
+    resp = `$T.array(${parseOapiSchema(os?.items)}, ${optArg})`
   } else if (os.type === 'object') {
+    let props = Object.entries(os?.properties || {})
+    .map(([k, v]) => `"${k}":${parseOapiSchema(v)}`)
+    .join(',')
     if (extra?.media === 'multipart/form-data') {
-      resp = `$T.multipartForm({${Object.entries(os?.properties || {})
-        .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
-        .join(',')}}${optArg})`
+      resp = `$T.multipartForm({${props}}${optArg ? `, ${optArg}`:''})`
     } else if (extra?.media === 'application/x-www-form-urlencoded') {
-      resp = `$T.urlForm({${Object.entries(os?.properties || {})
-        .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
-        .join(',')}}${optArg})`
+      resp = `$T.urlForm({${props}}${optArg ? `, ${optArg}`:''})`
     } else {
-      resp = `$T.object({${Object.entries(os?.properties || {})
-        .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
-        .join(',')}}${optArg})`
+      resp = `$T.object({${props}}${optArg ? `, ${optArg}`:''})`
     }
-  } else throw new Error(`Unknown schema type ${os.type}`)
+  } else throw new Error(`Unknown schema type ${JSON.stringify(os)}`)
 
   if (!required && nullable) resp = `$T.nullish(${resp})`
   else if (!required) resp = `$T.optional(${resp})`
@@ -188,13 +195,21 @@ const buildSchemaIndex = (def: OpenAPIV3.Document) => {
     let dependsOn = new Set<string>()
     if (kind === 'schemas') schema = parseOapiSchema(s, { id: k })
     else if (kind === 'requestBodies' || kind === 'responses') {
-      let schemas = [
-        ...new Set(
-          Object.entries((s as OpenAPIV3.RequestBodyObject).content || {}).map(([media, v]) =>
-            parseOapiSchema(v.schema, { id: k }, { media })
+      let schemas=[] as string[]
+      if(!!s.content){
+
+        schemas = [
+          ...new Set(
+            Object.entries((s as OpenAPIV3.RequestBodyObject)?.content || {null:{}}).map(([media, v]) => {
+              return parseOapiSchema(v.schema, { id: k }, { media })
+            })
           )
-        )
-      ]
+        ]
+      } else {
+        schemas = [
+          parseOapiSchema(undefined, {id: k, ...s})
+        ]
+      }
       schema = schemas.length <= 0 ? '' : schemas.length === 1 ? schemas[0] : `$T.union([${schemas.join(',')}])`
     }
     schema = unref(schema, m => {
@@ -225,26 +240,33 @@ const parseEndpointDef = (method: string, path: string, def?: OpenAPIV3.Operatio
   if (!def) return {}
   let imports = {}
   let p = path.replaceAll(/\{([^\}]*)\}/g, ':$1')
-  let description = def.summary || def.description
+  // let description = def.summary || def.description
   let pathName = path.replaceAll(/\/\{[^\}]*\}/g, 'X').replaceAll(/[^$\w\d_]+([$\w\d_])/g, (_, $1) => $1.toUpperCase())
   let schemaName = `${method}${pathName}`.replace(/^\w/, c => c.toUpperCase())
 
   let meta = '/**\n'
-  if (description) meta += ` * ${description.replace('\n', '\n * ')}\n`
+  if (def.summary) meta += ` * ${def.summary}\n *\n`
+  if (def.description) meta += ` * ${def.description.replace('\n', '\n * ')}\n`
   if (def.operationId) meta += ` * @operationId ${def.operationId}\n`
   if (def.externalDocs) meta += ` * @externalDocs ${def.externalDocs}\n`
   if (def.tags) meta += ` * @tags ${def.tags.join(' ')}\n`
   if (def.deprecated) meta == ' * @deprecated\n'
   meta += ' */'
-  let endpoint = `${method}("${p}", ${schemaName}, ctx => {\n  throw new Error("Not implemented")\n})`
+  let endpoint = `${method}("${p}", ${schemaName}, ctx => {\n  throw new NotImplementedError()\n})`
 
   let sp = { path: {}, query: {}, header: {}, body: {}, formData: {} } // TODO handle body and formData cases
   for (let _p of def?.parameters || []) {
     // @ts-ignore: TODO handle refs cases
     if (_p.$ref) continue
     let p = _p as OpenAPIV3.ParameterObject
-    let o = (s: string) => (p.in !== 'path' && !p.required ? `$T.optional(${s})` : s)
-    sp[p.in][p.name] = o(parseOapiSchema(p.schema))
+    let o = (s: string) => (p.in !== 'path' && !p.required && !/^\$T.optional\(.*\)$/.test(s) ? `$T.optional(${s})` : s)
+    sp[p.in][p.name] = o(
+      unref(parseOapiSchema(p.schema, {description: p.description }), m => {
+        let l = m.split('/')
+        imports[l[l.length - 1]] = m
+        return l[l.length - 1]
+      })
+    )
   }
 
   let [schemaParams, schemaQuery, schemaHeaders] = [
@@ -254,34 +276,36 @@ const parseEndpointDef = (method: string, path: string, def?: OpenAPIV3.Operatio
   ].map(({ g, o }) =>
     Object.keys(sp[o]).length
       ? `  ${g}: {${Object.entries(sp[o])
-          .map(([k, v]) => `${k}:${v}`)
+          .map(([k, v]) => `"${k}":${v}`)
           .join(',')}}`
       : ''
   )
 
   let body = ''
-  let _rb = def?.requestBody as OpenAPIV3.ReferenceObject
-  if (_rb?.$ref) {
-    body = unref(`  body: %ref:${_rb.$ref}%`, m => {
-      let l = m.split('/')
-      imports[l[l.length - 1]] = m
-      return l[l.length - 1]
-    })
-  } else {
-    let rb = def?.requestBody as OpenAPIV3.RequestBodyObject
-    let o = (s: string) => (!rb.required ? `$T.optional(${s})` : s)
-    let bs = [
-      ...new Set(
-        Object.entries(rb?.content || {}).map(([media, v]) =>
-          unref(parseOapiSchema(v.schema, undefined, { media }), m => {
-            let l = m.split('/')
-            imports[l[l.length - 1]] = m
-            return l[l.length - 1]
-          })
+  if(!['get', 'options', 'head'].includes(method)){
+    let _rb = def?.requestBody as OpenAPIV3.ReferenceObject
+    if (_rb?.$ref) {
+      body = unref(`  body: %ref:${_rb.$ref}%`, m => {
+        let l = m.split('/')
+        imports[l[l.length - 1]] = m
+        return l[l.length - 1]
+      })
+    } else {
+      let rb = def?.requestBody as OpenAPIV3.RequestBodyObject
+      let o = (s: string) => (!rb?.required ? `$T.optional(${s})` : s)
+      let bs = [
+        ...new Set(
+          Object.entries(rb?.content || {null:{}}).map(([media, v]) =>
+            unref(parseOapiSchema(v.schema, undefined, { media }), m => {
+              let l = m.split('/')
+              imports[l[l.length - 1]] = m
+              return l[l.length - 1]
+            })
+          )
         )
-      )
-    ]
-    body = bs.length === 1 ? `  body: ${o(bs[0])}` : bs.length > 1 ? `  body: ${o(`$T.union(${bs.join(',')})`)}` : ''
+      ]
+      body = bs.length === 1 ? `  body: ${o(bs[0])}` : bs.length > 1 ? `  body: ${o(`$T.union([${bs.join(',')}])`)}` : ''
+    }
   }
 
   let resp = ''
@@ -289,7 +313,18 @@ const parseEndpointDef = (method: string, path: string, def?: OpenAPIV3.Operatio
   let rs = Object.fromEntries(
     Object.entries(r || {}).map(([status, sv]) => {
       let entries: string[] = []
-      let s: string = Number.isInteger(Number(status)) ? status : '200'
+      let s: string = Number.isInteger(Number(status)) ? status : 'default'
+
+      //@ts-ignore
+      let rootRef = sv?.$ref ? unref(parseOapiSchema(sv), m => {
+        let l = m.split('/')
+        imports[l[l.length - 1]] = m
+        return l[l.length - 1]
+      }) : null
+      if (rootRef) {
+        return [s, [rootRef]]
+      }
+
       for (let [_type, tv] of Object.entries((sv as OpenAPIV3.ResponseObject)?.content || {})) {
         entries.push(
           unref(parseOapiSchema(tv.schema), m => {
@@ -306,7 +341,7 @@ const parseEndpointDef = (method: string, path: string, def?: OpenAPIV3.Operatio
   if (Object.keys(rs).length) {
     resp = `  response: {${Object.entries(rs)
       .filter(([_, v]) => v.length)
-      .map(([s, v]) => `${s}: ${v.length === 1 ? v[0] : v.length > 1 ? `$T.union(${v.join(',')})` : ''}`)
+      .map(([s, v]) => `${s}: ${v.length === 1 ? v[0] : v.length > 1 ? `$T.union([${v.join(',')}])` : ''}`)
       .join(',')}}`
   } else resp = ''
 
@@ -394,7 +429,7 @@ const writeFiles = async (
     })
     if (decl.length === 0) return ''
     return `import type { Static } from 'galbe/schema'\nimport { $T } from 'galbe'\n${Object.entries(imports)
-      .map(([k, v]) => `import { ${v.join(', ')} } from './${typeMap[k]}.schema'\n`)
+      .map(([k, v]) => `import { ${[...new Set(v)].join(', ')} } from './${typeMap[k]}.schema'\n`)
       .join('\n')}\n${decl.join('\n')}\n`
   }
 
@@ -461,7 +496,7 @@ const writeFiles = async (
       `${sDecl.map(d => d).join('\n\n')}\n`
 
     let routeFile =
-      `import type { Galbe } from 'galbe'\n` +
+      `import { NotImplementedError, type Galbe } from 'galbe'\n` +
       `import { ${[...rImports].join(', ')} } from '../schemas${scopeKey}.schema'\n\n` +
       `export default (g: Galbe) => {\n` +
       rDecl.map(d => d.replaceAll('\n', '\n  ')).join('\n\n') +

package/bin/commands/generate/code.ts

@@ -43,20 +43,21 @@ export default (cmd: Command) => {
 
       if (!format) format = `openapi:3.0:${inputExt.slice(1)}`
 
-      if ((await exists(resolve(CWD, out))) && !force) {
-        console.log(
-          `error: output directory ${fmtVal(
-            out
-          )} already exists. If you're sure you want to override its content, please remove it before or use the ${fmtVal(
-            '-F --force'
-          )} option`
-        )
-        process.exit(1)
+      if (await exists(resolve(CWD, out))) {
+        if(!force){
+          console.log(
+            `error: output directory ${fmtVal(
+              out
+            )} already exists. If you're sure you want to override its content, please remove it before or use the ${fmtVal(
+              '-F --force'
+            )} option`
+          )
+          process.exit(1)
+        }
+        await rm(resolve(CWD, out), { recursive: true })
       }
 
-      await rm(resolve(CWD, out), { recursive: true })
-
-      process.stdout.write('💻 \x1b[1;30mGenerating \x1b[36mGalbe\x1b[0m\x1b[1;30m sources\x1b[0m')
+      Bun.write(Bun.stdout, '💻 \x1b[1;30mGenerating \x1b[36mGalbe\x1b[0m\x1b[1;30m sources\x1b[0m')
       try {
         let match = format.match(/^([^:]*):([^:]*):(.*)$/)
         if (!match) throw new Error(`error: invalid format ${format}`)
@@ -70,6 +71,6 @@ export default (cmd: Command) => {
         console.log(`error: ${err.message}`)
         process.exit(1)
       }
-      process.stdout.write(' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      Bun.write(Bun.stdout, ' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
     })
 }

package/bin/commands/generate/spec.ts

@@ -54,7 +54,7 @@ export default (cmd: Command) => {
         pckg = await Bun.file(resolve(CWD, 'package.json')).json()
       } catch (e) {}
 
-      process.stdout.write(`📖 \x1b[1;30mGenerating ${target.split(':')?.[0]} spec\x1b[0m`)
+      Bun.write(Bun.stdout, `📖 \x1b[1;30mGenerating ${target.split(':')?.[0]} spec\x1b[0m`)
 
       let error = null
       let g: Galbe = await silentExec(async () => {
@@ -89,6 +89,6 @@ export default (cmd: Command) => {
         Bun.write(resolve(CWD, out), tFormat === 'json' ? JSON.stringify(openapiSpec, null, 2) : ymlDump(openapiSpec))
       }
 
-      process.stdout.write(' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      Bun.write(Bun.stdout, ' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
     })
 }