galbe 0.9.1 → 0.10.0

package/bin/commands/build.ts

@@ -9,9 +9,16 @@ import { CWD, fmtVal, silentExec } from '../util'
 import { Galbe } from '../../src'
 import { defineRoutes, GalbeProxy } from '../../src/routes'
 import { BuildConfig } from 'bun'
+import { existsSync } from 'fs'
 
 const createBuildIndex = async (indexPath: string, g: Galbe, buildId: string) => {
   const buildPath = resolve(tmpdir(), buildId)
+  const indexDir = dirname(indexPath)
+
+  let configPath = ''
+  if (existsSync(`${indexDir}/galbe.config.ts`)) configPath = `${indexDir}/galbe.config.ts`
+  else if (existsSync(`${indexDir}/galbe.config.js`)) configPath = `${indexDir}/galbe.config.js`
+
   const routes = new Map<string, { filepath: string, static?: { path: string, root: string } }>()
   let errors: any[] = []
   // Create GalbeProxy here
@@ -30,6 +37,9 @@ const createBuildIndex = async (indexPath: string, g: Galbe, buildId: string) =>
 
   let buildIndex =
     `import galbe from '${relative(buildPath, indexPath)}';\n` +
+    (configPath ? `import config from '${relative(buildPath, configPath)}';\n` : '') + 
+    (configPath ? `import {softMerge} from '${relative(buildPath, `${indexDir}/node_modules/galbe/src/util`)}';\n` : '') +
+    (configPath ? `let conf = galbe.config;\ngalbe.config = softMerge(config, conf)\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` +
@@ -92,10 +102,10 @@ export default (cmd: Command) => {
 
       const buildConfig: BuildConfig = {
         publicPath: `${outPath}/`,
-        ...Object.fromEntries(Object.entries(bunfig).filter(([k, v]) => v)),
+        sourcemap: 'external',
+        ...Object.fromEntries(Object.entries(bunfig).filter(([_, v]) => v)),
         entrypoints: [buildIndex],
         outdir: outPath,
-        sourcemap: 'external',
         target: 'bun',
       }
 

package/bin/commands/dev.ts

@@ -1,11 +1,13 @@
 import { $ } from 'bun'
 import { Command, Option } from 'commander'
-import { resolve } from 'path'
+import { resolve, dirname } from 'path'
 
-import { CWD, fmtInterval, fmtVal, instanciateRoutes, killPort, watchDir } from '../util'
+import { CWD, fmtInterval, fmtVal, instanciateRoutes, watchDir } from '../util'
 import { Galbe } from '../../src'
+import { softMerge } from '../../src/util'
+import { existsSync } from 'fs'
 
-const defaultPort = 3000
+const DEFAULT_PORT = 3000
 
 export default (cmd: Command) => {
   cmd
@@ -18,29 +20,29 @@ export default (cmd: Command) => {
           console.log(`error: port range must be between ${fmtInterval(1, 65535)}`)
           process.exit(1)
         })
-        .default(null, fmtVal(defaultPort))
+        .default(null, fmtVal(DEFAULT_PORT))
     )
-    .addOption(new Option('-w, --watch <dir>', '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(
-        false,
-        fmtVal(false)
-      )
-    )
     .action(async (index, props) => {
-      const { port, watch, watchignore, noclear, force } = props
-      let watch_dir = typeof watch === 'string' ? watch : CWD
-      const clear = !noclear
+      const { port, watch, watchignore, noclear } = props
       const indexPath = resolve(CWD, index)
+      const indexDir = dirname(indexPath)
+      let watch_dir = typeof watch === 'string' ? watch : watch ? indexDir : ''
+      const clear = !noclear
+      let galbeConfig = {}
       let g: Galbe
 
-      if (!Bun.env.BUN_ENV) Bun.env.BUN_ENV = 'development'
+      if (existsSync(`${indexDir}/galbe.config.ts`)) {
+        galbeConfig = (await import(`${indexDir}/galbe.config.ts`)).default
+      } else if (existsSync(`${indexDir}/galbe.config.js`)) {
+        galbeConfig = (await import(`${indexDir}/galbe.config.js`)).default
+      }
 
-      if (force) await killPort(port || 3000)
+      if (!Bun.env.BUN_ENV) Bun.env.BUN_ENV = 'development'
 
-      if (!!watch) {
+      if (!!watch_dir) {
         await watchDir(
           watch_dir,
           async () => {
@@ -55,8 +57,10 @@ export default (cmd: Command) => {
         )
       }
 
-      if (!!watch && clear) await $`clear`
+      if (!!watch_dir && clear) await $`clear`
       g = (await import(indexPath)).default
+      let conf = g.config
+      g.config = softMerge(galbeConfig, conf)
       await instanciateRoutes(g)
       await g.listen(port)
     })

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

@@ -282,7 +282,7 @@ const parseEndpointDef = (method: string, path: string, def?: OpenAPIV3.Operatio
   )
 
   let body = ''
-  if(!['get', 'options', 'head'].includes(method)){
+  if(!['get', 'delete', 'options', 'head'].includes(method)){
     let _rb = def?.requestBody as OpenAPIV3.ReferenceObject
     if (_rb?.$ref) {
       body = unref(`  body: %ref:${_rb.$ref}%`, m => {

package/bin/commands/generate/spec.ts

@@ -1,9 +1,11 @@
 import { Command, Option } from 'commander'
 import { resolve, relative, extname } from 'path'
 import { dump as ymlDump, load as ymlLoad } from 'js-yaml'
-import { CWD, fmtList, instanciateRoutes, silentExec, softMerge } from '../../util'
+import { CWD, fmtList, instanciateRoutes, silentExec } from '../../util'
 import { Galbe } from '../../../src'
 import { OpenAPISerializer } from '../../../src/extras'
+import { softMerge } from '../../../src/util'
+import { OpenAPIV3 } from 'openapi-types'
 
 const specTargets = ['openapi:3.0:json', 'openapi:3.0:yaml']
 const parsePckgAuthoRgx = /^\s*([^<(]*)(?:<([^>]+)>)?\s*(?:\(([^)]*)\))?\s*$/
@@ -85,7 +87,7 @@ export default (cmd: Command) => {
             version: pckg?.version || '0.1.0'
           }
         }
-        openapiSpec = softMerge(openapiSpec, baseSpec)
+        openapiSpec = softMerge(openapiSpec, baseSpec) as OpenAPIV3.Document
         Bun.write(resolve(CWD, out), tFormat === 'json' ? JSON.stringify(openapiSpec, null, 2) : ymlDump(openapiSpec))
       }
 

package/bin/util.ts

@@ -1,8 +1,8 @@
 import { relative } from 'path'
 import { watch } from 'chokidar'
-import { Galbe, Route } from '../src'
+import { Galbe, type Route } from '../src'
 import { logRoute, walkRoutes } from '../src/util'
-import { GalbeProxy, RouteMeta, defineRoutes } from '../src/routes'
+import { GalbeProxy, type RouteMeta, defineRoutes } from '../src/routes'
 
 export { default as pckg } from '../package.json'
 
@@ -15,7 +15,7 @@ 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 => 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) => {
@@ -95,16 +95,6 @@ export const instanciateRoutes = async (g: Galbe) => {
   console.log('\x1b[1;30m\x1b[32mdone\x1b[0m\n')
 }
 
-export const softMerge = (base, override) => {
-  for (const key in override) {
-    if (override[key] instanceof Object && !(override[key] instanceof Array)) {
-      if (!base[key]) Object.assign(base, { [key]: {} })
-      softMerge(base[key], override[key])
-    } else Object.assign(base, { [key]: override[key] })
-  }
-  return base
-}
-
 export const killPort = async (port: number) => {
   let getProcCmd: string[], killCmd: (port: string) => string[]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "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

@@ -240,12 +240,12 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       responses = Object.fromEntries(
         Object.entries(r.schema.response).map(([status, v]) => {
           if(!v) return []
-          let s = Number(status) as keyof typeof HttpStatus
+          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[Number(s) as keyof typeof HttpStatus] || 'Response',
+            description: v.description || HttpStatus[s as keyof typeof HttpStatus] || 'Response',
             content: { [media]: { schema: schema } }
           }
           if (components.responses && r.schema.response?.[s]?.id) {
@@ -261,9 +261,12 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
         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: meta?.head,
+      summary: summary,
       operationId: meta?.operationId,
       parameters: parameters.length ? parameters : undefined,
       requestBody,

package/src/index.ts

@@ -111,6 +111,8 @@ export const $T = new SchemaType()
 
 export { RequestError } from './types'
 
+export const config = (config: GalbeConfig) => config
+
 /**
  * #### Galbe Server
  * Instanciate a Galbe web server
@@ -136,13 +138,10 @@ export class Galbe {
   plugins: GalbePlugin[] = []
   constructor(config?: GalbeConfig) {
     this.config = config ?? {}
-    this.config.routes = this.config.routes ?? true
     this.router = new GalbeRouter({
       prefix: this.config?.basePath || '',
       cacheEnabled: this.config?.router?.cacheEnabled
     })
-    this.config.requestValidator = config?.requestValidator ?? { enabled: true }
-    this.config.responseValidator = config?.responseValidator ?? { enabled: true }
   }
   private add(route: any) {
     this.router.add(route)

package/src/routes.ts

@@ -234,7 +234,7 @@ export const defineRoutes = async (
   options: Pick<GalbeConfig, 'routes'>,
   proxy: GalbeProxy,
 ) => {
-  const routes = options?.routes === true ? DEFAULT_ROUTE_PATTERN : options?.routes
+  const routes = options?.routes === undefined || options?.routes === true ? DEFAULT_ROUTE_PATTERN : options?.routes
   if (!routes) return
   const root = process.cwd()
   if (typeof routes === 'string') {

package/src/server.ts

@@ -30,6 +30,7 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
 
   const server = Bun.serve({
     port: port || galbe.config?.port || 3000,
+    reusePort: galbe?.config?.reusePort,
     hostname: hostname || galbe.config?.hostname || 'localhost',
     tls: galbe.config?.tls,
 
@@ -81,7 +82,7 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
         context.params = inParams
 
         // request validation
-        if (galbe.config?.requestValidator?.enabled) {
+        if (galbe.config?.requestValidator?.enabled !== false) {
           let errors: RequestError[] = []
           try {
             if (schema?.headers)
@@ -150,7 +151,7 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
 
         const parsedResponse = responseParser(response, context as Context, schema.response)
 
-        if (galbe.config?.responseValidator?.enabled && schema.response)
+        if (galbe.config?.responseValidator?.enabled !== false && schema.response)
           validateResponse(response, schema.response, parsedResponse.status || 200)
 
         for (const p of pluginsCb.afterHandle) {
@@ -172,14 +173,20 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
             headers: { 'Content-Type': 'application/json' }
           })
         } else if (error instanceof RequestError) {
-          let payload = ''
-          if (typeof error.payload === 'string') payload = error.payload
-          try {
-            payload = JSON.stringify(error.payload)
-          } catch (err) { }
+          let payload = error.payload
+          let headers = new Headers(error?.headers || {})
+          if (!headers.has('content-type')) {
+            if (typeof error.payload === 'string') headers.set('content-type', 'text/plain')
+            else {
+              headers.set('content-type', 'application/json')
+              try {
+                payload = JSON.stringify(error.payload)
+              } catch (err) { }
+            }
+          }
           return new Response(payload, {
             status: error.status,
-            headers: { 'Content-Type': 'application/json' }
+            headers
           })
         } else console.log(error)
         return new Response('"Internal Server Error"', {

package/src/types.ts

@@ -99,15 +99,25 @@ export type STQuery = Record<string, STQueryValue>
  * ```
  */
 export type GalbeConfig = {
+  /** The port number that the server will be listening on. */
   port?: number
+  /** Allow to share the same port across processes (Linux only). */
+  reusePort?: boolean
+  /** The hostname of the server. */
   hostname?: string
+  /** The base path is added as a prefix to all the routes created. */
   basePath?: string
+  /** Enable or disable TLS support. */
   tls?: TLSOptions
   server?: Exclude<ServeOptions, 'port'> | TLSServeOptions
+  /** A Glob Pattern or a list of Glob patterns defining the route files to be analyzed by the Automatic Route Analyzer. */
   routes?: boolean | string | string[]
   router?: { cacheEnabled: boolean }
+  /** A property that can be used by plugins to add plugin's specific configuration. */
   plugin?: Record<string, any>
+  /** Enable or disable the request schema validation.*/
   requestValidator?: { enabled: boolean }
+  /** Enable or disable the response schema validation.*/
   responseValidator?: { enabled: boolean }
 }
 /**
@@ -245,10 +255,12 @@ export type StaticEndpoint<P extends string = string, T extends string = string>
 
 export class RequestError {
   status: number
-  payload: any
-  constructor(options: { status?: number; payload?: any }) {
+  payload?: any
+  headers?: Record<string, string>
+  constructor(options: { status?: number; payload?: any, headers?: Record<string, string> }) {
     this.status = options.status ?? 500
     this.payload = options.payload
+    this.headers = options.headers
   }
 }
 

package/src/util.ts

@@ -12,6 +12,15 @@ const METHOD_COLOR: Record<string, string> = {
 }
 const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g
 
+export const softMerge = <T> (base: T, override: T): T => {
+  for (const key in override) {
+    if (override[key] instanceof Object && !(override[key] instanceof Array)) {
+      if (!base[key]) Object.assign(base as any, { [key]: {} })
+      softMerge(base[key], override[key])
+    } else Object.assign(base as any, { [key]: override[key] })
+  }
+  return base
+}
 export const logRoute = (
   r: { method: string; path: string, static?: { path: string, root: string } },
   meta?: RouteMeta,