galbe 0.1.13 → 0.3.0

package/src/server.ts

@@ -3,6 +3,9 @@ import type { Context, Route } from './types'
 import { InternalError, RequestError } from './types'
 import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
 import { Galbe } from './index'
+import { validateResponse } from './validator'
+
+const LOADABLE_METHODS = ['POST', 'PUT', 'PATCH']
 
 const handleInternalError = (error: any) => {
   console.error(error)
@@ -10,26 +13,11 @@ const handleInternalError = (error: any) => {
 }
 
 const setupPluginCallbacks = (galbe: Galbe) => ({
-  init: galbe.plugins.reduce((l: { name: string; cb: Function }[], p) => {
-    if (p.init) l.push({ name: p.name, cb: p.init })
-    return l
-  }, []),
-  onFetch: galbe.plugins.reduce((l: Function[], p) => {
-    if (p.onFetch) l.push(p.onFetch)
-    return l
-  }, []),
-  onRoute: galbe.plugins.reduce((l: Function[], p) => {
-    if (p.onRoute) l.push(p.onRoute)
-    return l
-  }, []),
-  beforeHandle: galbe.plugins.reduce((l: Function[], p) => {
-    if (p.beforeHandle) l.push(p.beforeHandle)
-    return l
-  }, []),
-  afterHandle: galbe.plugins.reduce((l: Function[], p) => {
-    if (p.afterHandle) l.push(p.afterHandle)
-    return l
-  }, [])
+  init: galbe.plugins.filter(p => p.init),
+  onFetch: galbe.plugins.filter(p => p.onFetch),
+  onRoute: galbe.plugins.filter(p => p.onRoute),
+  beforeHandle: galbe.plugins.filter(p => p.beforeHandle),
+  afterHandle: galbe.plugins.filter(p => p.afterHandle)
 })
 
 export default async (galbe: Galbe, port?: number) => {
@@ -37,7 +25,8 @@ export default async (galbe: Galbe, port?: number) => {
   if (galbe?.config?.basePath && galbe?.config?.basePath[0] !== '/')
     galbe.config.basePath = `/${galbe?.config?.basePath}`
   let pluginsCb = setupPluginCallbacks(galbe)
-  for (const { name, cb } of pluginsCb.init) await cb(galbe?.config?.plugin?.[name], galbe)
+  //@ts-ignore
+  for (const p of pluginsCb.init) await p.init(galbe?.config?.plugin?.[p.name], galbe)
 
   return Bun.serve({
     port: port || galbe.config?.port || 3000,
@@ -51,8 +40,9 @@ export default async (galbe: Galbe, port?: number) => {
         body: {},
         state: {}
       }
-      for (const cb of pluginsCb.onFetch) {
-        const r = await cb(req)
+      for (const p of pluginsCb.onFetch) {
+        //@ts-ignore
+        const r = await p.onFetch(context)
         if (r) return r
       }
       const url = new URL(req.url)
@@ -66,9 +56,11 @@ export default async (galbe: Galbe, port?: number) => {
           if (error instanceof RequestError) throw error
           else throw handleInternalError(error)
         }
+        context.route = route
 
-        for (const cb of pluginsCb.onRoute) {
-          const r = await cb(route)
+        for (const p of pluginsCb.onRoute) {
+          //@ts-ignore
+          const r = await p.onRoute(context)
           if (r) return r
         }
 
@@ -80,41 +72,46 @@ export default async (galbe: Galbe, port?: number) => {
         for (let [k, v] of url.searchParams) inQuery[k] = v
         let inParams = requestPathParser(url.pathname, route.path)
 
-        context.body = await requestBodyParser(req.body, inHeaders, schema.body)
+        context.body = LOADABLE_METHODS.includes(req.method)
+          ? await requestBodyParser(req.body, inHeaders, schema.body)
+          : null
         context.headers = inHeaders
         context.query = inQuery
         context.params = inParams
 
         // request validation
-        let errors: RequestError[] = []
-        try {
-          if (schema?.headers)
-            context.headers = {
-              ...context.headers,
-              ...parseEntry(context.headers, schema.headers, { name: 'headers', i: true })
-            }
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        try {
-          if (schema?.query) context.query = parseEntry(context.query, schema.query, { name: 'query' })
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        try {
-          if (schema?.params) context.params = parseEntry(context.params, schema.params, { name: 'params' })
-        } catch (error) {
-          if (error instanceof RequestError) errors.push(error)
-          else throw handleInternalError(error)
-        }
-        if (errors.length) {
-          throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
+        if (galbe.config?.requestValidator?.enabled) {
+          let errors: RequestError[] = []
+          try {
+            if (schema?.headers)
+              context.headers = {
+                ...context.headers,
+                ...parseEntry(context.headers, schema.headers, { name: 'headers', i: true })
+              }
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          try {
+            if (schema?.query) context.query = parseEntry(context.query, schema.query, { name: 'query' })
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          try {
+            if (schema?.params) context.params = parseEntry(context.params, schema.params, { name: 'params' })
+          } catch (error) {
+            if (error instanceof RequestError) errors.push(error)
+            else throw handleInternalError(error)
+          }
+          if (errors.length) {
+            throw new RequestError({ status: 400, payload: errors.reduce((acc, c) => ({ ...acc, ...c.payload }), {}) })
+          }
         }
 
-        for (const cb of pluginsCb.beforeHandle) {
-          const r = await cb(context)
+        for (const p of pluginsCb.beforeHandle) {
+          //@ts-ignore
+          const r = await p.beforeHandle(context)
           if (r) return r
         }
 
@@ -152,8 +149,12 @@ export default async (galbe: Galbe, port?: number) => {
 
         const parsedResponse = responseParser(response, context)
 
-        for (const cb of pluginsCb.afterHandle) {
-          const r = await cb(parsedResponse)
+        if (galbe.config?.responseValidator?.enabled && schema.response)
+          validateResponse(response, schema.response, context.set.status || 200)
+
+        for (const p of pluginsCb.afterHandle) {
+          //@ts-ignore
+          const r = await p.afterHandle(parsedResponse, context)
           if (r) return r
         }
 
@@ -163,8 +164,19 @@ export default async (galbe: Galbe, port?: number) => {
         let customError
         if (galbe.errorHandler) customError = responseParser(galbe.errorHandler(error, context), context)
         if (customError) return customError
-        if (error instanceof RequestError) {
-          return new Response(JSON.stringify(error.payload), {
+        if (error instanceof InternalError) {
+          console.log(`Internal Error`, error?.payload || '')
+          return new Response('Internal Server Error', {
+            status: error.status,
+            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) {}
+          return new Response(payload, {
             status: error.status,
             headers: { 'Content-Type': 'application/json' }
           })

package/src/types.ts

@@ -22,12 +22,27 @@ export type STBody =
   | STBoolean
   | STNumber
   | STInteger
+  | STLiteral
   | STObject
   | STArray
   | STUrlForm
   | STMultipartForm
   | STUnion
   | STStream
+
+export type STResponseValue =
+  | STByteArray
+  | STString
+  | STBoolean
+  | STNumber
+  | STInteger
+  | STLiteral
+  | STObject
+  | STArray
+  | STUnion
+  | STStream
+export type STResponse = Record<number, STResponseValue>
+
 export type MaybeArray<T> = T | T[]
 
 export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
@@ -74,6 +89,8 @@ export type GalbeConfig = {
   routes?: boolean | string | string[]
   router?: { cacheEnabled: boolean }
   plugin?: Record<string, any>
+  requestValidator?: { enabled: boolean }
+  responseValidator?: { enabled: boolean }
 }
 /**
  * #### Schema
@@ -96,15 +113,17 @@ export type GalbeConfig = {
  */
 export type RequestSchema<
   Path extends string = string,
-  H extends STHeaders = {},
-  P extends Partial<STParams<Path>> = {},
-  Q extends STQuery = {},
-  B extends STBody = STBody
+  H extends STHeaders = STHeaders,
+  P extends Partial<STParams<Path>> = Partial<STParams<Path>>,
+  Q extends STQuery = STQuery,
+  B extends STBody = STBody,
+  R extends STResponse = STResponse
 > = {
   headers?: H
   params?: P
   query?: Q
   body?: B
+  response?: R
 }
 
 type OmitNotDefined<S extends RequestSchema> = {
@@ -124,6 +143,7 @@ export type Context<Path extends string = string, S extends RequestSchema = Requ
   query: Static<STObject<Exclude<S['query'], undefined>>>
   body: Static<Exclude<S['body'], undefined>>
   request: Request
+  route?: Route
   state: Record<string, any>
   set: {
     headers: {
@@ -146,44 +166,48 @@ export type Endpoint = {
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    schema: RequestSchema<Path, H, P, Q, B>,
-    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    schema: RequestSchema<Path, H, P, Q, B, R>,
+    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[],
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    schema: RequestSchema<Path, H, P, Q, B>,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    schema: RequestSchema<Path, H, P, Q, B, R>,
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B>>[],
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[],
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
     H extends STHeaders,
     P extends Partial<STParams<Path>>,
     Q extends STQuery,
-    B extends STBody = any
+    B extends STBody = any,
+    R extends STResponse = STResponse
   >(
     path: Path,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
   ): void
 }
 
@@ -192,7 +216,7 @@ export class RequestError {
   payload: any
   constructor(options: { status?: number; payload?: any }) {
     this.status = options.status ?? 500
-    this.payload = options.payload ?? 'Internal server error'
+    this.payload = options.payload
   }
 }
 
@@ -209,14 +233,15 @@ export type Route<
   H extends STHeaders = {},
   P extends Partial<STParams<Path>> = {},
   Q extends STQuery = {},
-  B extends STBody = STBody
+  B extends STBody = STBody,
+  R extends STResponse = STResponse
 > = {
   method: Method
   path: Path
-  schema: RequestSchema<Path, H, P, Q, B>
-  context: Context<Path, RequestSchema<Path, H, P, Q, B>>
+  schema: RequestSchema<Path, H, P, Q, B, R>
+  context: Context<Path, RequestSchema<Path, H, P, Q, B, R>>
   hooks: Hook[]
-  handler: Handler<Path, RequestSchema<Path, H, P, Q, B>>
+  handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
 }
 
 export type RouteTree = {
@@ -224,13 +249,13 @@ export type RouteTree = {
 }
 
 export class NotFoundError extends RequestError {
-  constructor(message?: string) {
+  constructor(message?: any) {
     super({ status: 404, payload: message ?? 'Not found' })
   }
 }
 
 export class InternalError extends RequestError {
-  constructor(message?: string) {
+  constructor(message?: any) {
     super({ status: 500, payload: message ?? 'Internal Server Error' })
   }
 }
@@ -259,8 +284,8 @@ export class InternalError extends RequestError {
 export type GalbePlugin = {
   name: string
   init?: (config: any, galbe: Galbe) => MaybePromise<void>
-  onFetch?: (request: Request) => MaybePromise<Response | void>
-  onRoute?: (route: Route) => MaybePromise<Response | void>
+  onFetch?: (context: Context) => MaybePromise<Response | void>
+  onRoute?: (context: Context) => MaybePromise<Response | void>
   beforeHandle?: (context: Context) => MaybePromise<Response | void>
-  afterHandle?: (response: Response) => MaybePromise<Response | void>
+  afterHandle?: (response: Response, context: Context) => MaybePromise<Response | void>
 }

package/src/util.ts

@@ -1,3 +1,5 @@
+import type { RouteFileMeta } from './routes'
+
 const METHOD_COLOR: Record<string, string> = {
   get: '\x1b[32m',
   post: '\x1b[34m',
@@ -6,7 +8,21 @@ const METHOD_COLOR: Record<string, string> = {
   delete: '\x1b[31m',
   options: ''
 }
-export const logRoute = (r: { method: string; path: string }) => {
+
+export const extractMetaRoute = (route: { path: string; method: string }, meta?: Array<RouteFileMeta>) => {
+  return meta?.map(e => (route.path in e.routes ? e.routes[route.path]?.[route.method] : null)).filter(e => e)?.[0]
+}
+
+export const logRoute = (
+  r: { method: string; path: string },
+  meta?: Record<string, boolean | string | string[]> | null
+) => {
   let color = METHOD_COLOR?.[r.method] || ''
-  console.log(`    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}`)
+  console.log(
+    `    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}${
+      meta?.head ? ` - ${meta.head}` : ''
+    }`
+  )
 }
+
+export const isIterator = (obj: any) => typeof obj?.next === 'function'

package/src/validator.ts

@@ -1,5 +1,7 @@
+import { InternalError, type STResponse } from './index'
 import type { STSchema, STProps, STUnion } from './schema'
-import { Kind, Optional } from './schema'
+import { Kind, Optional, Stream } from './schema'
+import { isIterator } from './util'
 
 export const validate = (elt: any, schema: STSchema, parse = false): any => {
   type ValidationError = string | string[] | { [key: string]: ValidationError }
@@ -7,7 +9,10 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   const iElt = elt
 
   if (schema[Kind] === 'boolean') {
-    if (parse && typeof elt === 'string') elt = elt === 'true' ? true : elt === 'false' ? false : null
+    if (typeof elt === 'string') {
+      if (parse) elt = elt === 'true' ? true : elt === 'false' ? false : null
+      else throw `Expected boolean, got string.`
+    }
     if (elt !== true && elt !== false) throw `${iElt} is not a valid boolean. Should be 'true' or 'false'`
   } else if (schema[Kind] === 'integer') {
     if (parse && typeof elt === 'string') elt = Number(elt)
@@ -84,6 +89,22 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   return elt
 }
 
+export const validateResponse = (response: any, schema: STResponse, status: number) => {
+  if (!(status in schema)) return
+  const s = schema[status]
+  if (response instanceof ReadableStream) {
+    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got ReadableStream`)
+  } else if (isIterator(response)) {
+    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got Iterator`)
+  } else {
+    try {
+      validate(response, s)
+    } catch (error) {
+      throw new InternalError({ ResponseValidationError: error })
+    }
+  }
+}
+
 const schemaValidation = (value: any, schema: STSchema) => {
   const errors = []
   if (schema[Kind] === 'integer' || schema[Kind] === 'number') {
@@ -92,9 +113,8 @@ const schemaValidation = (value: any, schema: STSchema) => {
     if (schema.exclusiveMax !== undefined)
       if ((value as number) >= schema.exclusiveMax)
         errors.push(`${value} is greater or equal to ${schema.exclusiveMax}`)
-    if (schema.minimum !== undefined)
-      if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
-    if (schema.maximum !== undefined)
+    if (schema.min !== undefined) if ((value as number) < schema.min) errors.push(`${value} is less than ${schema.min}`)
+    if (schema.max !== undefined)
       if ((value as number) > schema.max) errors.push(`${value} is greater than ${schema.max}`)
   } else if (schema[Kind] === 'string') {
     if (schema.minLength !== undefined && (value as string).length < schema.minLength)

package/test/plugins.test.ts

@@ -39,8 +39,8 @@ describe('plugins', async () => {
     let request: any = null
     const plugin: GalbePlugin = {
       name: 'dev.galbe.test.init',
-      onFetch: mock(req => {
-        request = req
+      onFetch: mock(ctx => {
+        request = ctx.request
       })
     }
 
@@ -86,7 +86,7 @@ describe('plugins', async () => {
     const plugin: GalbePlugin = {
       name: 'dev.galbe.test.init',
       onRoute: mock(r => {
-        route = r
+        route = r.route
       })
     }