galbe 0.3.0 → 0.4.1

package/src/types.ts

@@ -1,13 +1,17 @@
 import type { ServeOptions, TLSServeOptions } from 'bun'
 import type {
+  STAny,
   STArray,
   STBoolean,
   STByteArray,
   STInteger,
+  STJson,
   STLiteral,
   STMultipartForm,
   STNumber,
   STObject,
+  STOptional,
+  STSchema,
   STStream,
   STString,
   STUnion,
@@ -29,6 +33,7 @@ export type STBody =
   | STMultipartForm
   | STUnion
   | STStream
+  | undefined
 
 export type STResponseValue =
   | STByteArray
@@ -38,14 +43,18 @@ export type STResponseValue =
   | STInteger
   | STLiteral
   | STObject
+  | STJson
   | STArray
   | STUnion
   | STStream
+  | STAny
 export type STResponse = Record<number, STResponseValue>
 
 export type MaybeArray<T> = T | T[]
+export type MaybeSTArray<T extends STSchema> = T | STArray<T>
+export type MaybeSTUnion<T extends STSchema> = T | STUnion<[T, ...T[]]>
 
-export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options'
+export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head'
 type MaybePromise<T> = T | Promise<T>
 
 export type ExtractParams<T extends string> = T extends `/:${infer P}/${infer Rest}`
@@ -56,13 +65,16 @@ export type ExtractParams<T extends string> = T extends `/:${infer P}/${infer Re
   ? P
   : never
 
-type STHeadersValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+type STHeadersPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
+type STHeadersValue = MaybeSTUnion<STHeadersPrimaryValue>
 export type STHeaders = Record<string, STHeadersValue>
 
-type STParamsValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+type STParamsPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
+type STParamsValue = MaybeSTUnion<STParamsPrimaryValue>
 export type STParams<Path extends string = string> = Record<ExtractParams<Path>, STParamsValue>
 
-type STQueryValue = STString | STBoolean | STNumber | STInteger | STLiteral | STUnion
+type STQueryPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
+type STQueryValue = MaybeSTArray<MaybeSTUnion<STQueryPrimaryValue>>
 export type STQuery = Record<string, STQueryValue>
 
 /**
@@ -112,6 +124,7 @@ export type GalbeConfig = {
  * ```
  */
 export type RequestSchema<
+  M extends Method = Method,
   Path extends string = string,
   H extends STHeaders = STHeaders,
   P extends Partial<STParams<Path>> = Partial<STParams<Path>>,
@@ -134,14 +147,18 @@ type OmitNotDefined<S extends RequestSchema> = {
     : //@ts-ignore
       never]: Static<STObject<Exclude<S['params'], undefined>>>[K]
 }
-
-export type Context<Path extends string = string, S extends RequestSchema = RequestSchema> = {
+type StaticBody<T extends STSchema> = T extends STOptional<STSchema> ? Static<T> | null : Static<T>
+export type Context<
+  M extends Method = Method,
+  Path extends string = string,
+  S extends RequestSchema = RequestSchema
+> = {
   headers: Static<STObject<Exclude<S['headers'], undefined>>>
   params: {
     [K in ExtractParams<Path>]: K extends keyof OmitNotDefined<S> ? OmitNotDefined<S>[K] : string
   }
   query: Static<STObject<Exclude<S['query'], undefined>>>
-  body: Static<Exclude<S['body'], undefined>>
+  body: M extends 'get' | 'options' | 'head' ? null : StaticBody<Exclude<S['body'], undefined>>
   request: Request
   route?: Route
   state: Record<string, any>
@@ -153,61 +170,63 @@ export type Context<Path extends string = string, S extends RequestSchema = Requ
   }
 }
 export type Next = () => void | Promise<void>
-export type Hook<Path extends string = string, S extends RequestSchema = RequestSchema> = (
-  ctx: Context<Path, S>,
+export type Hook<M extends Method = Method, Path extends string = string, S extends RequestSchema = RequestSchema> = (
+  ctx: Context<M, Path, S>,
   next: Next
 ) => any | Promise<any>
-export type Handler<Path extends string = string, S extends RequestSchema = RequestSchema> = (
-  ctx: Context<Path, S>
-) => any
-export type Endpoint = {
+export type Handler<
+  M extends Method = Method,
+  Path extends string = string,
+  S extends RequestSchema = RequestSchema
+> = (ctx: Context<M, Path, S>) => any
+export type Endpoint<M extends Method> = {
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
+    H extends STHeaders = any,
+    Q extends STQuery = any,
     B extends STBody = any,
     R extends STResponse = STResponse
   >(
     path: Path,
-    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>>
+    schema: RequestSchema<M, Path, H, P, Q, B, R>,
+    hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
+    H extends STHeaders = any,
+    Q extends STQuery = any,
     B extends STBody = any,
     R extends STResponse = STResponse
   >(
     path: Path,
-    schema: RequestSchema<Path, H, P, Q, B, R>,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
+    schema: RequestSchema<M, Path, H, P, Q, B, R>,
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
+    H extends STHeaders = any,
+    Q extends STQuery = any,
     B extends STBody = any,
     R extends STResponse = STResponse
   >(
     path: Path,
-    hooks: Hook<Path, RequestSchema<Path, H, P, Q, B, R>>[],
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
+    hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
   <
     Path extends string,
-    H extends STHeaders,
     P extends Partial<STParams<Path>>,
-    Q extends STQuery,
+    H extends STHeaders = any,
+    Q extends STQuery = any,
     B extends STBody = any,
     R extends STResponse = STResponse
   >(
     path: Path,
-    handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
+    handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   ): void
 }
 
@@ -223,29 +242,26 @@ export class RequestError {
 export type ErrorHandler = (error: any, context: Context) => any
 
 export type RouteNode = {
-  route?: Route
+  routes: { [K in Method]?: Route }
   param?: RouteNode
   children?: Record<string, RouteNode>
 }
 
 export type Route<
+  M extends Method = Method,
   Path extends string = string,
-  H extends STHeaders = {},
   P extends Partial<STParams<Path>> = {},
-  Q extends STQuery = {},
+  H extends STHeaders = STHeaders,
+  Q extends STQuery = STQuery,
   B extends STBody = STBody,
   R extends STResponse = STResponse
 > = {
-  method: Method
+  method: M
   path: Path
-  schema: RequestSchema<Path, H, P, Q, B, R>
-  context: Context<Path, RequestSchema<Path, H, P, Q, B, R>>
+  schema: RequestSchema<M, Path, H, P, Q, B, R>
+  context: Context<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
   hooks: Hook[]
-  handler: Handler<Path, RequestSchema<Path, H, P, Q, B, R>>
-}
-
-export type RouteTree = {
-  [key: string]: RouteNode
+  handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
 }
 
 export class NotFoundError extends RequestError {
@@ -254,6 +270,12 @@ export class NotFoundError extends RequestError {
   }
 }
 
+export class MethodNotAllowedError extends RequestError {
+  constructor(message?: any) {
+    super({ status: 405, payload: message ?? 'Method not allowed' })
+  }
+}
+
 export class InternalError extends RequestError {
   constructor(message?: any) {
     super({ status: 500, payload: message ?? 'Internal Server Error' })
@@ -262,7 +284,7 @@ export class InternalError extends RequestError {
 
 /**
  * #### GalbePlugin
- * Define a plugin for a Galbe server
+ * Define a plugin for a Galbe application
  *
  * ---
  * @example
@@ -288,4 +310,14 @@ export type GalbePlugin = {
   onRoute?: (context: Context) => MaybePromise<Response | void>
   beforeHandle?: (context: Context) => MaybePromise<Response | void>
   afterHandle?: (response: Response, context: Context) => MaybePromise<Response | void>
+  cli?: (commands: GalbeCLICommand[]) => MaybePromise<GalbeCLICommand[] | void>
+}
+
+export type GalbeCLICommand = {
+  name: string
+  description?: string
+  route: Route
+  arguments?: { name: string; type: string; description: string }[]
+  options?: { name: string; short: string; type: string; description: string; default: any }[]
+  action?: (props: any) => MaybePromise<void>
 }

package/src/util.ts

@@ -1,4 +1,5 @@
-import type { RouteFileMeta } from './routes'
+import type { Route, RouteNode } from '.'
+import type { RouteMeta } from './routes'
 
 const METHOD_COLOR: Record<string, string> = {
   get: '\x1b[32m',
@@ -6,23 +7,88 @@ const METHOD_COLOR: Record<string, string> = {
   put: '\x1b[36m',
   patch: '\x1b[33m',
   delete: '\x1b[31m',
-  options: ''
-}
-
-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]
+  options: '',
+  head: ''
 }
 
 export const logRoute = (
   r: { method: string; path: string },
-  meta?: Record<string, boolean | string | string[]> | null
+  meta?: RouteMeta,
+  format?: { maxPathLength?: number }
 ) => {
   let color = METHOD_COLOR?.[r.method] || ''
   console.log(
-    `    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path}${
-      meta?.head ? ` - ${meta.head}` : ''
-    }`
+    `    [${color}${`${r.method.toUpperCase()}\x1b[0m]`.padEnd(12, ' ')} ${r.path
+      .padEnd(format?.maxPathLength ?? r.path.length, ' ')
+      .replaceAll(/:([^\/]+)/g, '\x1b[0;33m:$1\x1b[0m')}${meta?.head ? `  ${meta.head}` : ''}`
   )
 }
 
+export const walkRoutes = (node: RouteNode, cb: (route: Route) => void) => {
+  if (node?.routes) Object.values(node.routes).forEach(r => cb(r))
+  for (let c of Object.values(node?.children || {})) walkRoutes(c, cb)
+  if (node?.param) walkRoutes(node.param, cb)
+}
+
 export const isIterator = (obj: any) => typeof obj?.next === 'function'
+
+export const HttpStatus = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Moved Temporarily',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Request Entity Too Large',
+  414: 'Request-URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a teapot",
+  419: 'Insufficient Space on Resource',
+  420: 'Method Failure',
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  507: 'Insufficient Storage',
+  511: 'Network Authentication Required'
+}

package/src/validator.ts

@@ -50,6 +50,8 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
       }
     })
     if (Object.keys(err).length) errors.push(err)
+  } else if (schema[Kind] === 'json') {
+    elt = validate(elt, { ...schema, [Kind]: schema.type }, parse)
   } else if (schema[Kind] === 'array') {
     if (parse && typeof elt === 'string') {
       try {

package/test/parser.test.ts

@@ -10,6 +10,7 @@ import {
   isAsyncIterator
 } from './test.utils'
 import { Galbe, $T } from '../src'
+import { schemaToTypeStr } from '../src/schema'
 
 const port = 7357
 
@@ -1195,4 +1196,37 @@ describe('parser', () => {
       expect(body).toEqual(expected.body)
     }
   })
+
+  test('schema to type', async () => {
+    let type = schemaToTypeStr(
+      $T.object({
+        boolean: $T.boolean(),
+        byteArray: $T.byteArray(),
+        number: $T.number(),
+        integer: $T.integer(),
+        string: $T.string(),
+        any: $T.any(),
+        literal: $T.literal('literal'),
+        array: $T.array($T.string()),
+        object: $T.object({
+          foo: $T.string()
+        }),
+        union: $T.union([$T.number(), $T.string()])
+      })
+    )
+    expect(type).toBe(
+      `{` +
+        `'boolean':boolean;` +
+        `'byteArray':Uint8Array;` +
+        `'number':number;` +
+        `'integer':number;` +
+        `'string':string;` +
+        `'any':any;` +
+        `'literal':'literal';` +
+        `'array':Array<string>;` +
+        `'object':{'foo':string};` +
+        `'union':number|string` +
+        `}`
+    )
+  })
 })

package/test/requests.test.ts

@@ -1,18 +1,9 @@
 import { expect, test, describe, beforeAll } from 'bun:test'
 import { Galbe, $T } from '../src'
-import {
-  formdata,
-  type Case,
-  fileHash,
-  schema_objectBase,
-  schema_object,
-  handleBody,
-  isAsyncIterator,
-  handleUrlFormStream
-} from './test.utils'
+import { formdata, type Case, fileHash, handleBody, isAsyncIterator } from './test.utils'
 
 const port = 7358
-const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options']
+const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head']
 
 describe('requests', () => {
   beforeAll(async () => {
@@ -24,6 +15,7 @@ describe('requests', () => {
     galbe.patch('/test', () => {})
     galbe.delete('/test', () => {})
     galbe.options('/test', () => {})
+    galbe.head('/test', () => {})
 
     galbe.get('/headers', ctx => {
       return ctx.headers
@@ -76,7 +68,8 @@ describe('requests', () => {
           p2: $T.number(),
           p3: $T.boolean(),
           p4: $T.union([$T.number(), $T.boolean()]),
-          p5: $T.optional($T.string())
+          p5: $T.optional($T.string()),
+          p6: $T.array($T.union([$T.string()]))
         }
       },
       ctx => {

package/test/resources/test.route.comment.ts

@@ -35,4 +35,24 @@ export default (g: Galbe) => {
    * @other Hello Mom!
    */
   g.put('/test', { body: $T.object({ foo: $T.string() }) }, [() => {}], _ => {})
+
+  /**
+   * patch method
+   */
+  g.patch('/test', _ => {})
+
+  /**
+   * options method
+   */
+  g.options('/test', _ => {})
+
+  /**
+   * delete method
+   */
+  g.delete('/test', _ => {})
+
+  /**
+   * head method
+   */
+  g.head('/test', _ => {})
 }

package/test/responses.test.ts

@@ -50,6 +50,10 @@ describe('responses', () => {
     galbe.post('/bool', { response: { 200: $T.boolean() } }, handleResp)
     galbe.post('/num', { response: { 200: $T.number() } }, handleResp)
     galbe.post('/str', { response: { 200: $T.string() } }, handleResp)
+    galbe.post('/json/bool', { response: { 200: $T.json($T.boolean()) } }, handleResp)
+    galbe.post('/json/num', { response: { 200: $T.json($T.number()) } }, handleResp)
+    galbe.post('/json/str', { response: { 200: $T.json($T.string()) } }, handleResp)
+    galbe.post('/json/obj', { response: { 200: $T.json($T.object()) } }, handleResp)
     galbe.post('/arr', { response: { 200: $T.array() } }, handleResp)
     galbe.post('/obj', { response: { 200: $T.object($T.any()) } }, handleResp)
     galbe.post('/stream/ba', { response: { 200: $T.stream($T.byteArray()) } }, ctx =>
@@ -126,14 +130,23 @@ describe('responses', () => {
       }
     })
 
-    const body = await resp.json()
+    const reader = resp.body?.getReader()
+    let body = new Uint8Array()
+    while (reader) {
+      const { value, done } = await reader.read()
+      if (done) break
+      let buff = new Uint8Array(body.length + value.length)
+      buff.set(body)
+      buff.set(value, body.length)
+      body = buff
+    }
 
     expect(resp.status).toBe(200)
-    expect(resp.headers.get('content-type')).toBe('application/json')
+    expect(resp.headers.get('content-type')).toBe('application/octet-stream')
     expect(body).toEqual(reqBody)
   })
 
-  test('response, ba, validation failed', async () => {
+  test('response, ba, validation error', async () => {
     let bodyStr = 'Hello mom!'
 
     let resp = await fetch(`http://localhost:${port}/ba`, {
@@ -166,7 +179,7 @@ describe('responses', () => {
     expect(body).toEqual(reqBody)
   })
 
-  test('response, bool, validation failed', async () => {
+  test('response, bool, validation error', async () => {
     let bodyStr = 'true'
 
     let resp = await fetch(`http://localhost:${port}/bool`, {
@@ -199,7 +212,7 @@ describe('responses', () => {
     expect(body).toEqual(reqBody)
   })
 
-  test('response, num, validation failed', async () => {
+  test('response, num, validation error', async () => {
     let bodyStr = '"test"'
 
     let resp = await fetch(`http://localhost:${port}/num`, {
@@ -231,10 +244,95 @@ describe('responses', () => {
     expect(body).toEqual(bodyStr)
   })
 
-  test('response, str, validation failed', async () => {
+  test('response, json bool, validation OK', async () => {
+    let bodyStr = 'false'
+    let reqBody = false
+
+    let resp = await fetch(`http://localhost:${port}/json/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    const body = await resp.json()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('application/json')
+    expect(body).toEqual(reqBody)
+  })
+
+  test('response, json bool, validation error', async () => {
     let bodyStr = '3.14'
 
-    let resp = await fetch(`http://localhost:${port}/str`, {
+    let resp = await fetch(`http://localhost:${port}/json/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, json num, validation OK', async () => {
+    let bodyStr = '42'
+    let reqBody = 42
+
+    let resp = await fetch(`http://localhost:${port}/json/num`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    const body = await resp.json()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('application/json')
+    expect(body).toEqual(reqBody)
+  })
+
+  test('response, json num, validation error', async () => {
+    let bodyStr = '"Hi"'
+
+    let resp = await fetch(`http://localhost:${port}/json/bool`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    expect(resp.status).toBe(500)
+  })
+
+  test('response, json str, validation OK', async () => {
+    let bodyStr = '"Hello Mom!"'
+    let reqBody = 'Hello Mom!'
+
+    let resp = await fetch(`http://localhost:${port}/json/str`, {
+      method: 'POST',
+      body: bodyStr,
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    const body = await resp.json()
+
+    expect(resp.status).toBe(200)
+    expect(resp.headers.get('content-type')).toBe('application/json')
+    expect(body).toEqual(reqBody)
+  })
+
+  test('response, json str, validation error', async () => {
+    let bodyStr = '3.14'
+
+    let resp = await fetch(`http://localhost:${port}/json/str`, {
       method: 'POST',
       body: bodyStr,
       headers: {
@@ -264,7 +362,7 @@ describe('responses', () => {
     expect(body).toEqual(reqBody)
   })
 
-  test('response, array, validation failed', async () => {
+  test('response, array, validation error', async () => {
     let bodyStr = '0'
 
     let resp = await fetch(`http://localhost:${port}/arr`, {
@@ -297,7 +395,7 @@ describe('responses', () => {
     expect(body).toEqual(reqBody)
   })
 
-  test('response, object, validation failed', async () => {
+  test('response, object, validation error', async () => {
     let bodyStr = '"This"'
 
     let resp = await fetch(`http://localhost:${port}/obj`, {
@@ -334,7 +432,7 @@ describe('responses', () => {
     expect(body).toMatch(new RegExp(`id:${UUID_RGX}\ndata:Hello\n\nid:${UUID_RGX}\ndata:Mom!\n\n`))
   })
 
-  test('response, stream ba, validation failed', async () => {
+  test('response, stream ba, validation error', async () => {
     let bodyStr = ''
 
     let resp = await fetch(`http://localhost:${port}/stream/ba`, {
@@ -368,7 +466,7 @@ describe('responses', () => {
     expect(body).toMatch(new RegExp(`id:${UUID_RGX}\ndata:Hello\n\nid:${UUID_RGX}\ndata:Mom!\n\n`))
   })
 
-  test('response, stream str, validation failed', async () => {
+  test('response, stream str, validation error', async () => {
     let bodyStr = '0'
 
     let resp = await fetch(`http://localhost:${port}/stream/str`, {