galbe 0.13.1 → 0.14.0

package/src/parser.ts

@@ -1,4 +1,4 @@
-import type { MaybeArray, STBody, Context, STResponse, STBodyValue, STBodyType } from './index'
+import type { MaybeArray, STBody, Context, STResponse, STBodyContent, STBodyValue } from './index'
 import type {
   STStream,
   STMultipartForm,
@@ -13,13 +13,14 @@ import type {
   STPropsValue,
   STUnion,
   STIntersection,
+  STArray,
 } from './schema'
 
 import { readableStreamToArrayBuffer } from 'bun'
 import { Kind, Optional, Stream } from './schema'
 import { validate } from './validator'
-import { InternalError, RequestError } from './index'
-import { isIterator } from './util'
+import { InternalServerError, RequestError } from './index'
+import { isIterator, inferBodyType, type ParseMode } from './util'
 
 const textDecoder = new TextDecoder()
 const textEncoder = new TextEncoder()
@@ -36,10 +37,16 @@ export const requestBodyParser = async (
   body: ReadableStream | null,
   headers: Record<string, string>,
   schemas?: STBody | STNull,
-  contentType?: STBodyType
+  contentType?: string
 ) => {
-  let schema: STBodyValue =
-    (schemas as STNull)?.[Kind] === 'null' ? schemas : contentType ? schemas?.[contentType] : undefined
+  const normalizedCT = contentType?.split(';')[0]?.trim()
+  let parseMode: ParseMode = inferBodyType(contentType)
+  let schema: STBodyValue | STNull | undefined =
+    (schemas as STNull)?.[Kind] === 'null'
+      ? (schemas as STNull)
+      : normalizedCT
+        ? ((schemas as STBodyContent)?.[normalizedCT as `${string}/${string}`] ?? (schemas as STBodyContent)?.['*/*'])
+        : (schemas as STBodyContent)?.['*/*']
   let kind = schema?.[Kind]
   let isStream = schema && Stream in schema
   try {
@@ -48,11 +55,11 @@ export const requestBodyParser = async (
       throw new RequestError({ status: 400, payload: { body: `Expected null body` } })
     }
     if (!schemas || !Object.keys(schemas).length) {
-      // No schema defined, we base parsing on contentType only
-      if (contentType === 'byteArray') {
+      // No schema defined, we base parsing on parseMode only
+      if (parseMode === 'byteArray') {
         if (body === null) return new Uint8Array()
         return new Uint8Array(await readableStreamToArrayBuffer(body))
-      } else if (contentType === 'json') {
+      } else if (parseMode === 'json') {
         if (body === null) return null
         try {
           return JSON.parse(await streamToString(body))
@@ -62,25 +69,25 @@ export const requestBodyParser = async (
             payload: { body: err?.message ?? 'Parsing error' },
           })
         }
-      } else if (contentType === 'text') {
+      } else if (parseMode === 'text') {
         if (body === null) return ''
         return streamToString(body)
-      } else if (contentType === 'urlForm') {
+      } else if (parseMode === 'urlForm') {
         if (body === null) return {}
         return await streamToUrlForm(body)
-      } else if (contentType === 'multipart') {
+      } else if (parseMode === 'multipart') {
         if (body === null) return {}
-        const boundary = headers?.['content-type'].match(/boundary\="?([^"]*)"?;?.*$/)?.[1] || ''
+        const boundary = headers?.['content-type']?.match(/boundary\="?([^"]*)"?;?.*$/)?.[1] || ''
         return await streamToMultipartForm(body, boundary)
       } else return body === null ? null : rsToAsyncIterator(body)
     } else {
       // Schemas found
-      if (contentType === 'default' && (schema || Object.values(schemas).every(s => s?.[Optional]))) {
-        if (kind === 'byteArray') contentType = 'byteArray'
-        else if (kind === 'string') contentType = 'text'
+      if (parseMode === 'default' && (schema || Object.values(schemas).every(s => s?.[Optional]))) {
+        if (kind === 'byteArray') parseMode = 'byteArray'
+        else if (kind === 'string') parseMode = 'text'
         else return body === null ? null : rsToAsyncIterator(body)
       }
-      if (contentType === 'byteArray') {
+      if (parseMode === 'byteArray') {
         if (kind !== 'byteArray') throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
         if (body === null) {
           return isStream
@@ -94,8 +101,8 @@ export const requestBodyParser = async (
         }
         if (isStream) return rsToAsyncIterator(body)
         return new Uint8Array(await readableStreamToArrayBuffer(body))
-      } else if (contentType === 'text') {
-        if (!['string', 'boolean', 'number', 'integer', 'union', 'literal'].includes(kind))
+      } else if (parseMode === 'text') {
+        if (!kind || !['string', 'boolean', 'number', 'integer', 'anyOf', 'oneOf', 'literal'].includes(kind))
           throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
         if (body === null)
           return isStream
@@ -105,27 +112,28 @@ export const requestBodyParser = async (
                   controller.close()
                 },
               })
-            : validate('', schema, { parse: true })
+            : validate('', schema as STSchema, { parse: true })
         if (isStream) return $streamToString(body)
-        if (kind === 'union') {
+        if (kind === 'anyOf' || kind === 'oneOf') {
           let str = await streamToString(body)
-          return unionize(str, schema)
+          return unionize(str, schema as STUnion)
         }
         return await streamToString(body, schema as STBodyValue)
-      } else if (contentType === 'json') {
+      } else if (parseMode === 'json') {
         if (
-          !['object', 'json', 'boolean', 'number', 'integer', 'string', 'array', 'union', 'intersection'].includes(kind)
+          !kind ||
+          !['object', 'json', 'boolean', 'number', 'integer', 'string', 'array', 'anyOf', 'oneOf', 'intersection'].includes(kind)
         )
           throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
-        if (kind === 'union') {
+        if (kind === 'anyOf' || kind === 'oneOf') {
           let str = body === null ? 'null' : await streamToString(body)
           let json = JSON.parse(str)
-          return unionize(json, schema)
+          return unionize(json, schema as STUnion)
         }
         if (kind === 'intersection') {
           let str = body === null ? 'null' : await streamToString(body)
           let json = JSON.parse(str)
-          return intersectionize(json, schema)
+          return intersectionize(json, schema as STIntersection<any>)
         }
         const str = body === null ? 'null' : await streamToString(body)
         let json
@@ -137,9 +145,9 @@ export const requestBodyParser = async (
             payload: { body: err?.message ?? 'Parsing error' },
           })
         }
-        return validate(json, schema, { parse: true })
-      } else if (contentType === 'urlForm') {
-        if (!['object', 'union'].includes(kind))
+        return validate(json, schema as STSchema, { parse: true })
+      } else if (parseMode === 'urlForm') {
+        if (!kind || !['object', 'anyOf', 'oneOf'].includes(kind))
           throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
         if (body === null)
           return isStream
@@ -156,16 +164,17 @@ export const requestBodyParser = async (
                     controller.close()
                   },
                 }),
-                schema
+                schema as STObject
               )
-        if (kind === 'union') {
+        if (kind === 'anyOf' || kind === 'oneOf') {
           const b = await streamToUrlForm(body)
-          return unionize(b, schema)
+          return unionize(b, schema as STUnion)
         }
         if (isStream) return $streamToUrlForm(body, schema as STStream<STObject>)
         else return await streamToUrlForm(body, schema as STObject)
-      } else if (contentType === 'multipart') {
-        if (kind !== 'multipartForm') throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
+      } else if (parseMode === 'multipart') {
+        if (kind !== 'multipartForm' && kind !== 'anyOf' && kind !== 'oneOf')
+          throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
         if (body === null)
           return isStream
             ? new ReadableStream({
@@ -175,14 +184,14 @@ export const requestBodyParser = async (
                 },
               })
             : {}
-        const boundary = headers?.['content-type'].match(/boundary\="?([^"]*)"?;?.*$/)?.[1] || ''
-        if (kind === 'union') {
+        const boundary = headers?.['content-type']?.match(/boundary\="?([^"]*)"?;?.*$/)?.[1] || ''
+        if (kind === 'anyOf' || kind === 'oneOf') {
           let mp = await streamToMultipartForm(body, boundary)
-          return unionize(mp, schema)
+          return unionize(mp, schema as STUnion)
         }
         if (isStream) return $streamToMultipartForm(body, boundary, schema as STStream<STMultipartForm>)
         return streamToMultipartForm(body, boundary, schema as STMultipartForm)
-      } else if (contentType === 'default') {
+      } else if (parseMode === 'default') {
         throw new RequestError({ status: 400, payload: { body: `Not a valid content-type` } })
       }
     }
@@ -223,7 +232,8 @@ async function* $streamToUrlForm(
           decodeURIComponent(textDecoder.decode(bV)),
         ]
         try {
-          let s = schema?.props?.[key]?.[Kind] === 'array' ? schema?.props?.[key].items : schema?.props?.[key]
+          const propSchema = schema?.props?.[key]
+          let s = propSchema?.[Kind] === 'array' ? (propSchema as STArray).items : propSchema
           val = s ? paramParser(val, s) : val
         } catch (error) {
           throw new RequestError({ status: 400, payload: { body: { [key]: error } } })
@@ -254,7 +264,8 @@ async function* $streamToUrlForm(
     decodeURIComponent(textDecoder.decode(rest)),
   ]
   try {
-    let s = schema?.props?.[key]?.[Kind] === 'array' ? schema?.props?.[key].items : schema?.props?.[key]
+    const propSchema = schema?.props?.[key]
+    let s = propSchema?.[Kind] === 'array' ? (propSchema as STArray).items : propSchema
     val = s ? paramParser(val, s) : val
   } catch (error) {
     throw new RequestError({ status: 400, payload: { body: { [key]: error } } })
@@ -553,7 +564,7 @@ const paramParser = (
     let errors: Record<number, any> = {}
     for (let [idx, v] of value.entries()) {
       try {
-        pv.push(paramParser(v, type.items as STMultipartFormValues) as Static<STPropsValue>)
+        pv.push(paramParser(v, (type as STArray).items as STMultipartFormValues) as Static<STPropsValue>)
       } catch (error) {
         errors[idx] = error
       }
@@ -567,25 +578,26 @@ const paramParser = (
       if (value === 'false') return false
       else throw `Not a valid boolean. Should be 'true' or 'false'`
     } else if (type[Kind] === 'integer') {
-      if (value === null || value === undefined) throw `Not a valid integer`
-      const parsedValue = parseInt(value, 10)
-      if (isNaN(parsedValue) || String(parsedValue) !== String(value)) throw `Not a valid integer`
+      if (value === null || value === undefined || value === '') throw `Not a valid integer`
+      const parsedValue = Number(value)
+      if (!Number.isFinite(parsedValue) || !Number.isInteger(parsedValue)) throw `Not a valid integer`
       validate(parsedValue, type)
       return parsedValue
     } else if (type[Kind] === 'number') {
-      if (value === null || value === undefined) throw `Not a valid number`
+      if (value === null || value === undefined || value === '') throw `Not a valid number`
       const parsedValue = Number(value)
-      if (isNaN(parsedValue) || String(parsedValue) !== String(value)) throw `Not a valid number`
+      if (!Number.isFinite(parsedValue)) throw `Not a valid number`
       validate(parsedValue, type)
       return parsedValue
     } else if (type[Kind] === 'string') {
       validate(value, type)
       return value
     } else if (type[Kind] === 'literal') {
+      const lit = type as STLiteral
       let val: any = value
-      if (typeof type.value === 'boolean') val = value === 'true' ? true : value === 'false' ? false : value
-      if (typeof type.value === 'number') val = Number(value)
-      if (val !== type.value) throw `Not a valid value`
+      if (typeof lit.value === 'boolean') val = value === 'true' ? true : value === 'false' ? false : value
+      if (typeof lit.value === 'number') val = Number(value)
+      if (val !== lit.value) throw `Not a valid value`
       return val
     } else if (type[Kind] === 'object') {
       let json
@@ -596,11 +608,11 @@ const paramParser = (
       }
       return validate(json, type)
     } else if (type[Kind] === 'array') {
-      return [paramParser(value, type.items as STMultipartFormValues) as Static<STPropsValue>]
+      return [paramParser(value, (type as STArray).items as STMultipartFormValues) as Static<STPropsValue>]
     } else if (type[Kind] === 'byteArray') {
       return Uint8Array.from(value, c => c.charCodeAt(0))
-    } else if (type[Kind] === 'union') {
-      const union = Object.values(type.anyOf)
+    } else if (type[Kind] === 'anyOf' || type[Kind] === 'oneOf') {
+      const union = Object.values((type as STUnion).members)
       for (const elt of union) {
         try {
           return paramParser(value, elt as STMultipartFormValues)
@@ -639,7 +651,12 @@ export const requestPathParser = (input: string, path: string) => {
         }
         name += c
       }
-      params[name] = pInput[idx]
+      const raw = pInput[idx]
+      try {
+        params[name] = raw === undefined ? raw : decodeURIComponent(raw)
+      } catch {
+        params[name] = raw
+      }
     }
   }
   return params
@@ -681,11 +698,14 @@ export const parseEntry = <T extends STProps>(
   return parsedParams as Static<STObject<T>>
 }
 
-export const responseParser = (response: any, ctx: Context, schema?: STResponse) => {
+export const responseParser = (response: any, ctx: Context, cookies: string[], schema?: STResponse) => {
   const details = {
     status: ctx.set.status || 200,
     headers: new Headers(),
   }
+  for (const cookie of cookies) {
+    details.headers.append('set-cookie', cookie)
+  }
   for (const [key, value] of Object.entries(ctx.set.headers)) {
     if (Array.isArray(value)) {
       value.forEach(v => details.headers.append(key, v))
@@ -694,7 +714,11 @@ export const responseParser = (response: any, ctx: Context, schema?: STResponse)
   if (response instanceof Response) return response
   else if (typeof response === 'string') {
     if (!details?.headers?.has('content-type')) {
-      if (schema?.[details.status]?.[Kind] === 'json') {
+      const statusEntry: any = schema?.[details.status]
+      const isJson = statusEntry?.[Kind]
+        ? statusEntry[Kind] === 'json'
+        : statusEntry?.['application/json'] && !statusEntry?.['text/plain']
+      if (isJson) {
         details?.headers?.set('content-type', 'application/json')
         response = `"${response}"`
       } else details?.headers?.set('content-type', 'text/plain')
@@ -736,7 +760,7 @@ export const responseParser = (response: any, ctx: Context, schema?: STResponse)
       return new Response(response, details)
     } catch (error) {
       console.error(error)
-      throw new InternalError()
+      throw new InternalServerError()
     }
   }
 }
@@ -744,17 +768,16 @@ export const responseParser = (response: any, ctx: Context, schema?: STResponse)
 const unionize = (b: any, schema: STUnion) => {
   let res
   let error
-  const discirminants = schema.anyOf.reduce(
-    (acc, obj) =>
-      acc.filter(k => obj?.props && k in obj.props && obj.props[k]?.[Kind] === 'literal' && !obj.props[k]?.Optional),
-    Object.keys(schema.anyOf[0]?.props || {})
-  )
-  for (let s of schema.anyOf) {
+  const discriminants = schema.members.reduce((acc, obj) => {
+    const props = (obj as STObject).props
+    return acc.filter(k => props && k in props && props[k]?.[Kind] === 'literal' && !props[k]?.[Optional])
+  }, Object.keys((schema.members[0] as STObject)?.props || {}))
+  for (let s of schema.members) {
     try {
       res = validate(b, s, { parse: true })
       if (res !== undefined) break
     } catch (err: any) {
-      if (discirminants.every(d => !err?.[d]?.startsWith('Not a valid value'))) error = err
+      if (discriminants.every(d => !err?.[d]?.startsWith('Not a valid value'))) error = err
     }
   }
   if (res !== undefined) return res
@@ -762,7 +785,7 @@ const unionize = (b: any, schema: STUnion) => {
   else throw new RequestError({ status: 400, payload: { body: `No matching body schema found` } })
 }
 
-const intersectionize = (b: any, schema: STIntersection) => {
+const intersectionize = (b: any, schema: STIntersection<any>) => {
   let res
   try {
     for (let s of schema.allOf) res = validate(b, s, { parse: true })

package/src/router.ts

@@ -3,33 +3,47 @@ import { MethodNotAllowedError, NotFoundError } from './types'
 
 const ROUTE_REGEX = /^(\/(\*|:?\d+|:?\w+|:?[\w\d.][\w-.]+[\w\d]))*\/?$/
 
-const walk = (path: string[], node: RouteNode, alts: RouteNode[] = []): RouteNode => {
-  if (path.length < 1) throw new NotFoundError()
-  if (path.length === 1 && node.routes && !!Object.keys(node.routes).length) return node
+const walk = (path: string[], node: RouteNode, index: number = 0): RouteNode => {
+  if (index === path.length - 1) {
+    if (node.routes && !!Object.keys(node.routes).length) return node
+    // /a/* should match /a — fall back to a wildcard child if the node has no
+    // routes of its own.
+    const wc = node.children?.['*']
+    if (wc?.routes && !!Object.keys(wc.routes).length) return wc
+    throw new NotFoundError()
+  }
 
-  if (node.children?.['*']) alts.push(node.children['*'])
-  if (node.param) alts.push(node.param)
+  const nextSegment = path[index + 1]
 
-  if (node.children && path[1] in node.children) {
-    path.shift()
-    return walk(path, node.children[path[0]], alts)
+  // 1. Exact Match
+  if (node.children && nextSegment in node.children) {
+    try {
+      return walk(path, node.children[nextSegment], index + 1)
+    } catch (error) {
+      if (!(error instanceof NotFoundError)) throw error
+    }
   }
+
+  // 2. Param Match
   if (node.param) {
-    path.shift()
-    alts.pop()
-    return walk(path, node.param, alts)
-  }
-  if (alts.length > 1) {
-    return walk(path, alts.pop() as RouteNode, alts)
+    try {
+      return walk(path, node.param, index + 1)
+    } catch (error) {
+      if (!(error instanceof NotFoundError)) throw error
+    }
   }
-  if (alts.length === 1) {
-    let lastAlt = alts.pop() as RouteNode
+
+  // 3. Wildcard Match
+  if (node.children && '*' in node.children) {
     try {
-      return walk(path, lastAlt, alts)
+      return walk(path, node.children['*'], index + 1)
     } catch (error) {
       if (error instanceof NotFoundError) {
-        if (lastAlt?.routes) return lastAlt
-      } else throw error
+        if (node.children['*'].routes && !!Object.keys(node.children['*'].routes).length) {
+          return node.children['*']
+        }
+      }
+      if (!(error instanceof NotFoundError)) throw error
     }
   }
 
@@ -53,8 +67,8 @@ export class GalbeRouter {
     route.path = route?.path?.[0] === '/' ? route.path : `/${route.path}`
     if (!route.path.match(ROUTE_REGEX)) throw new SyntaxError(`${route.path} is not a valid route path.`)
     const isStatic = !route.path.match(/(:[\w\d-]+|\*)/)
-    if (isStatic) this.cachedRoutes.set(`[${route.method.toUpperCase()}]${route.path}`, route)
     route.path = `${this.prefix || ''}${route.path}`
+    if (isStatic) this.cachedRoutes.set(`[${route.method}]${route.path}`, route)
     let path = route.path.replace(/^\/+|\/+$/g, '').split('/')
     if (path[0] === '') path.shift()
     let r = this.routes

package/src/routes.ts

@@ -1,4 +1,3 @@
-import { cpSync } from 'fs'
 import type { GalbeConfig, GalbePlugin, Method, Route } from './types'
 
 import { readdir, lstat } from 'fs/promises'
@@ -39,6 +38,7 @@ export class GalbeProxy {
   _metaTmp?: RoutesMeta
   _filepath?: string
   _meta: Array<RouteFileMeta> = []
+  _staticTargets: Array<{ path: string; target: string }> = []
   constructor(g: Galbe, cb?: RouteInstanciationCallback) {
     this.#g = g
     this._cb = cb
@@ -110,23 +110,27 @@ export class GalbeProxy {
     return this.handleRoute('head', ...args)
   }
   async static(...args: any[]) {
-    if (!!Bun.env.GALBE_BUILD_OUT) {
-      let [_, target] = args
-      cpSync(target, `${Bun.env.GALBE_BUILD_OUT}/static-${Bun.env.GALBE_BUILD}/${target}`, { recursive: true, dereference: true })
+    const [path, target] = args
+    if (typeof path === 'string' && typeof target === 'string') {
+      this._staticTargets.push({ path, target })
     }
     return this.handleRoute('static', ...args)
   }
 }
 
 const parseComment = (comment: string): Record<string, string | string[]> => {
-  const head =
-    comment
-      .match(/^([^@]*)/)?.[1]
-      .replace(/^ *\* */gm, '')
-      .trim() || ''
+  // Find the first JSDoc-tag line (a line whose first non-whitespace/star
+  // character is `@`). Anything before it is the head; from it onwards is tags.
+  // We can't naively split on `@` because descriptions legitimately contain
+  // `@` (e.g. `@scope/name` package identifiers).
+  const tagLineRe = /^\s*\*?\s*@[a-zA-Z_][0-9a-zA-Z_]*(?:\s|$)/m
+  const m = comment.match(tagLineRe)
+  const headRaw = m && m.index !== undefined ? comment.slice(0, m.index) : comment
+  const head = headRaw.replace(/^ *\* */gm, '').trim() || ''
+  const tagsSrc = m && m.index !== undefined ? comment.slice(m.index) : ''
   const refs = {
     ...(head ? { head } : {}),
-    ...[...comment.matchAll(new RegExp(`^\\s*\\*\\s*@([a-zA-Z_][0-9a-zA-Z_]*)(?:$|\\s+([^\\n]*)\\s*$)`, 'gm'))].reduce(
+    ...[...tagsSrc.matchAll(new RegExp(`^\\s*\\*\\s*@([a-zA-Z_][0-9a-zA-Z_]*)(?:$|\\s+([^\\n]*)\\s*$)`, 'gm'))].reduce(
       (acc, n) => {
         return {
           ...acc,