galbe 0.13.0 → 0.14.0

package/src/schema.ts

@@ -7,7 +7,24 @@ export interface Options {
   title?: string
   description?: string
   default?: any
+  example?: any
+  /**
+   * On a response schema: a map of named examples (OpenAPI content-level
+   * `examples`). On any other schema: a single example value.
+   */
   examples?: any
+  /**
+   * Response-only: declares response headers. Each value is a Galbe schema
+   * describing the header's value type.
+   */
+  headers?: Record<string, any>
+  /** Marks the schema as deprecated. Surfaced by spec generators (e.g. OpenAPI). */
+  deprecated?: boolean
+  /**
+   * Response-only: declares response headers emitted in the OpenAPI `responses` object.
+   * Distinct from the request-level `headers` field.
+   */
+  responseHeaders?: Record<string, any>
 }
 export interface ByteArrayOptions extends Options {
   minLength?: number
@@ -17,6 +34,7 @@ export interface StringOptions extends Options {
   minLength?: number
   maxLength?: number
   pattern?: RegExp
+  format?: string
 }
 export interface NumberOptions extends Options {
   min?: number
@@ -44,14 +62,13 @@ export interface STSchema extends Options {
     | 'urlForm'
     | 'multipartForm'
     | 'any'
-    | 'union'
+    | 'anyOf'
+    | 'oneOf'
     | 'intersection'
   [Optional]?: boolean
   [Stream]?: boolean
   params: unknown[]
   static: unknown
-  props?: STProps
-  [key: string]: any
 }
 export type STPropsValue =
   | STBoolean
@@ -128,7 +145,7 @@ export function _Bool(options: Options = {}): STBoolean {
   } as unknown as STBoolean
 }
 // String
-export interface STString extends STSchema, NumberOptions {
+export interface STString extends STSchema, StringOptions {
   [Kind]: 'string'
   static: string
 }
@@ -179,7 +196,6 @@ export function _Literal<T extends STLiteralValue>(value: T, options: Options =
 export interface STAny extends STSchema, Options {
   [Kind]: 'any'
   static: any
-  [key: string]: any
 }
 export function _Any(options: Options = {}): STAny {
   return {
@@ -196,8 +212,8 @@ export interface STObject<T extends STProps = STProps> extends STSchema {
 }
 export interface STJson<T extends STBoolean | STNumber | STString | STObject = any> extends STSchema {
   [Kind]: 'json'
-  type: 'boolean' | 'number' | 'string' | 'object' | 'unknown'
   static: Static<T>
+  value: T
 }
 type ObjectStatic<T extends STProps, P extends unknown[]> = ObjectStaticProps<T, { [K in keyof T]: Static<T[K], P> }>
 type OptionalPropertyKeys<T extends STProps> = {
@@ -217,46 +233,18 @@ function _Object<T extends STProps>(properties?: T, options: Options = {}): STOb
     ? { ...options, [Kind]: 'object', props: clonedProperties, required: requiredKeys }
     : { ...options, [Kind]: 'object', props: clonedProperties }) as unknown as STObject<T>
 }
-function _Json<T extends STBoolean | STNumber | STString | STObject>(value?: T, options: Options = {}): STJson<T> {
-  if (value?.[Kind] === 'boolean') return { ..._Bool(options), [Kind]: 'json', type: 'boolean' }
-  if (value?.[Kind] === 'number') return { ..._Number(options), [Kind]: 'json', type: 'number' }
-  if (value?.[Kind] === 'string') return { ..._String(options), [Kind]: 'json', type: 'string' }
-  if (value?.[Kind] === 'object') return { ..._Object(value.props, options), [Kind]: 'json', type: 'object' }
-  throw Error('Invalid Json type definition')
+function _Json<T extends STBoolean | STNumber | STString | STObject>(value: T, options: Options = {}): STJson<T> {
+  const k = value?.[Kind]
+  if (k !== 'boolean' && k !== 'number' && k !== 'string' && k !== 'object') {
+    throw new Error('Invalid Json type definition')
+  }
+  return {
+    ...options,
+    [Kind]: 'json',
+    value,
+  } as unknown as STJson<T>
 }
 
-// UrlForm
-// export type STUrlFormValues =
-//   | STByteArray
-//   | STBoolean
-//   | STNumber
-//   | STInteger
-//   | STString
-//   | STLiteral
-//   | STObject
-//   | STUnion
-//   | STAny
-//   | STArray
-// export type STUrlFormProps = Record<string, STUrlFormValues>
-// export interface STUrlForm<T extends STUrlFormProps = STUrlFormProps> extends STSchema {
-//   [Kind]: 'urlForm'
-//   static: T extends undefined ? Record<string, any> : ObjectStatic<T, this['params']>
-//   props: T
-// }
-// function _UrlForm<T extends STUrlFormProps>(properties?: T, options: Options = {}): STUrlForm<T> {
-//   if (!properties) return { ...options, [Kind]: 'urlForm' } as unknown as STUrlForm<T>
-//   const propertyKeys = globalThis.Object.getOwnPropertyNames(properties)
-//   const optionalKeys = propertyKeys.filter(key => properties[key]?.[Optional])
-//   const requiredKeys = propertyKeys.filter(name => !optionalKeys.includes(name))
-//   const clonedProperties = propertyKeys.reduce(
-//     (acc, key) => ({ ...acc, [key]: { ...properties[key] } }),
-//     {} as STUrlFormProps
-//   )
-//   return (requiredKeys.length > 0
-//     ? { ...options, [Kind]: 'urlForm', props: clonedProperties, required: requiredKeys }
-//     : { ...options, [Kind]: 'urlForm', props: clonedProperties }) as unknown as STUrlForm<T>
-// }
-
 // MultipartForm
 export type STMultipartFormValues = STSchema
 export interface MultipartFormData<K extends string = string, V extends Static<STMultipartForm> = any> {
@@ -293,7 +281,7 @@ function _MultipartForm<T extends STProps>(properties?: T, options: Options = {}
 
 // Array
 type NonEmptyArray<T> = [T, ...T[]]
-export interface STArray<T extends STSchema = STSchema> extends STSchema {
+export interface STArray<T extends STSchema = STSchema> extends STSchema, ArrayOptions {
   [Kind]: 'array'
   static: Static<T>[]
   items: T
@@ -311,16 +299,19 @@ type UnionStatic<T extends STSchema[], P extends unknown[]> = {
   [K in keyof T]: T[K] extends STSchema ? Static<T[K], P> : never
 }[number]
 export interface STUnion<T extends NonEmptyArray<STSchema> = NonEmptyArray<STSchema>> extends STSchema {
-  [Kind]: 'union'
+  [Kind]: 'anyOf' | 'oneOf'
   static: UnionStatic<T, this['params']>
-  props: T[number]['props']
-  anyOf: T
+  members: T
 }
-export function _Union<T extends NonEmptyArray<STSchema>>(schemas: [...T], options: Options): STUnion<T> {
+export function _Union<T extends NonEmptyArray<STSchema>>(
+  kind: 'anyOf' | 'oneOf',
+  schemas: [...T],
+  options: Options
+): STUnion<T> {
   const s = {
     ...options,
-    [Kind]: 'union',
-    anyOf: schemas as T,
+    [Kind]: kind,
+    members: schemas as T,
     optional: () => ({ ...s, [Optional]: true }),
   }
   return s as unknown as STUnion<T>
@@ -334,15 +325,14 @@ type IntersectionStatic<T extends readonly STSchema[], P extends unknown[]> = T
       : never
     : never
   : unknown
-export interface STIntersection<T extends NonEmptyArray<STObject | STUnion | STIntersection> = NonEmptyArray<STObject>>
-  extends STSchema {
+// type Intersecs = NonEmptyArray<STObject | STUnion | STIntersection>
+export interface STIntersection<T extends NonEmptyArray<STObject | STUnion | STIntersection<any>>> extends STSchema {
   [Kind]: 'intersection'
   static: IntersectionStatic<T, this['params']>
-  props: T[number]['props']
   allOf: T
 }
 
-export function _Intersection<T extends NonEmptyArray<STObject | STUnion | STIntersection>>(
+export function _Intersection<T extends NonEmptyArray<STObject | STUnion | STIntersection<any>>>(
   schemas: [...T],
   options: Options
 ): STIntersection<T> {
@@ -350,24 +340,13 @@ export function _Intersection<T extends NonEmptyArray<STObject | STUnion | STInt
     ...options,
     [Kind]: 'intersection',
     allOf: schemas as T,
-    props: schemas.reduce(
-      (b, c) => ({
-        ...b,
-        ...(c.props || {}),
-        ...Object.fromEntries(
-          Object.entries(b).filter(([_, v]) => (v as STSchema)[Kind] === 'literal' || !(v as STSchema)[Optional])
-          // TODO: handle cases where left != right
-        ),
-      }),
-      {}
-    ) as STProps,
     optional: () => ({ ...s, [Optional]: true }),
   }
   return s as unknown as STIntersection<T>
 }
 
 // Stream
-type STStreamable = STByteArray | STString | STMultipartForm | STObject | STUnion | STIntersection
+type STStreamable = STByteArray | STString | STMultipartForm | STObject | STUnion | STIntersection<any>
 export function _Stream<T extends STStreamable>(schema: T): STStream<T> {
   return {
     ...schema,
@@ -377,7 +356,7 @@ export function _Stream<T extends STStreamable>(schema: T): STStream<T> {
 // Nullable
 type STNullable<T extends STSchema> = STUnion<[T, STNull]>
 // Nullish
-type STNullish<T extends STSchema> = (T | STNull) & { [Kind]: 'union'; anyOf: [T, STNull]; [Optional]: true }
+type STNullish<T extends STSchema> = (T | STNull) & { [Kind]: 'anyOf'; members: [T, STNull]; [Optional]: true }
 export class SchemaType {
   /** Creates an Optional Schema Type Wrapper */
   public optional<T extends STSchema>(schema: T): STOptional<T> {
@@ -385,7 +364,7 @@ export class SchemaType {
   }
   /** Creates an Nullable Schema Type Wrapper */
   public nullable<T extends STSchema>(schema: T): STNullable<T> {
-    return { ..._Union([schema, _Null()], {}) }
+    return { ..._Union('anyOf', [schema, _Null()], {}) }
   }
   /** Creates an Nullish Schema Type Wrapper */
   public nullish<T extends STSchema>(schema: T): STOptional<STNullable<T>> {
@@ -434,24 +413,28 @@ export class SchemaType {
   ): STJson<T> {
     return _Json(value, options)
   }
-  /** Creates an UrlForm Schema Type */
-  // public urlForm<T extends STUrlFormProps>(properties?: T, options: Options = {}): STUrlForm<T> {
-  //   return _UrlForm(properties, options)
-  // }
   /** Creates a MultipartForm Schema Type */
   public multipartForm<T extends STProps>(properties?: T, options: Options = {}): STMultipartForm<T> {
     return _MultipartForm(properties, options)
   }
   /** Creates an Array Schema Type */
-  public array<T extends STSchema>(schema?: T, options: Options = {}): STArray<T> {
+  public array<T extends STSchema>(schema?: T, options: ArrayOptions = {}): STArray<T> {
     return _Array(schema, options)
   }
-  /** Creates an Union Schema Type */
+  /** Creates an anyOf Schema Type (alias: `union`) */
+  public anyOf<T extends NonEmptyArray<STSchema>>(schemas: [...T], options: Options = {}): STUnion<T> {
+    return _Union('anyOf', schemas, options)
+  }
+  /** Creates a oneOf Schema Type */
+  public oneOf<T extends NonEmptyArray<STSchema>>(schemas: [...T], options: Options = {}): STUnion<T> {
+    return _Union('oneOf', schemas, options)
+  }
+  /** @deprecated Use `anyOf` instead */
   public union<T extends NonEmptyArray<STSchema>>(schemas: [...T], options: Options = {}): STUnion<T> {
-    return _Union(schemas, options)
+    return _Union('anyOf', schemas, options)
   }
   /** Creates an Intersection Schema Type */
-  public intersection<T extends NonEmptyArray<STObject | STUnion | STIntersection>>(
+  public intersection<T extends NonEmptyArray<STObject | STUnion | STIntersection<any>>>(
     schemas: [...T],
     options: Options = {}
   ): STIntersection<T> {
@@ -465,8 +448,8 @@ export class SchemaType {
       T['props'] extends undefined
         ? { [k: string]: Static<STPropsValue> }
         : T['props'] extends STProps
-        ? { [K in keyof T['props']]: [K, Static<T['props'][K]>] }[keyof T['props']]
-        : never
+          ? { [K in keyof T['props']]: [K, Static<T['props'][K]>] }[keyof T['props']]
+          : never
     >
     params: unknown[]
   }
@@ -475,24 +458,27 @@ export class SchemaType {
   ): Omit<STStream<T>, 'static'> & {
     static: AsyncGenerator<
       Entries<{
-        [P in KeysOfUnion<T['props']> as ValueAt<T['props'], P> extends STSchema ? P : never]: Static<
-          ValueAt<T['props'], P>
-        >
+        [P in KeysOfUnion<MemberProps<T['members'][number]>> as ValueAt<
+          MemberProps<T['members'][number]>,
+          P
+        > extends STSchema
+          ? P
+          : never]: Static<ValueAt<MemberProps<T['members'][number]>, P>>
       }>
     >
     params: unknown[]
   }
-  public stream<T extends STIntersection>(
+  public stream<T extends STIntersection<any>>(
     schema: T
   ): Omit<STStream<T>, 'static'> & {
     static: AsyncGenerator<
-      T['props'] extends undefined
+      MemberProps<T['allOf'][number]> extends undefined
         ? never
-        : T['props'] extends STProps
-        ? Entries<{
-            [K in keyof Static<T>]: Static<T>[K]
-          }>
-        : never
+        : MemberProps<T['allOf'][number]> extends STProps
+          ? Entries<{
+              [K in keyof Static<T>]: Static<T>[K]
+            }>
+          : never
     >
     params: unknown[]
   }
@@ -530,6 +516,7 @@ export class SchemaType {
 }
 type KeysOfUnion<U> = U extends unknown ? keyof U : never
 type ValueAt<U, K extends PropertyKey> = U extends unknown ? (K extends keyof U ? U[K] : never) : never
+type MemberProps<U> = U extends { props: infer P } ? P : never
 
 export const schemaToTypeStr = (schema: STSchema): string => {
   let type = 'unknown'
@@ -554,13 +541,13 @@ export const schemaToTypeStr = (schema: STSchema): string => {
       .map(([k, v]) => `${typeof k === 'string' ? `'${k}'` : k}${v?.[Optional] ? '?' : ''}:${schemaToTypeStr(v)}`)
       .join(';')}}`
   } else if (kind === 'json') {
-    type = `Json<${schemaToTypeStr({ ...schema, [Kind]: schema.type })}>`
-  } else if (kind === 'union') {
-    let anyOf = (schema as STUnion).anyOf
-    type = anyOf.map(s => schemaToTypeStr(s)).join('|')
+    type = `Json<${schemaToTypeStr((schema as STJson).value)}>`
+  } else if (kind === 'anyOf' || kind === 'oneOf') {
+    let members = (schema as STUnion).members
+    type = members.map(s => schemaToTypeStr(s)).join('|')
   } else if (kind === 'intersection') {
-    let allOf = (schema as STIntersection).allOf
-    type = allOf.map(s => schemaToTypeStr(s)).join('&')
+    let allOf = (schema as STIntersection<any>).allOf
+    type = allOf.map((s: STSchema) => schemaToTypeStr(s)).join('&')
   }
 
   // if (schema[Optional]) type = `${type}|undefined`

package/src/server.ts

@@ -1,10 +1,12 @@
 import type { Context, Method, Route } from './types'
 
-import { InternalError, RequestError } from './types'
+import { InternalServerError, RequestError } from './types'
 import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
 import { Galbe } from './index'
 import { validateResponse } from './validator'
-import { inferBodyType } from './util'
+const normalizeContentType = (ct: string | null): string | undefined =>
+  ct ? ct.split(';')[0].trim() || undefined : undefined
+import { readCookies, stringifyCookie } from './cookies'
 
 type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
 
@@ -13,7 +15,7 @@ const EMPTY_BODY_METHODS = ['GET', 'OPTIONS', 'HEAD']
 
 const handleInternalError = (error: any) => {
   console.error(error)
-  return new InternalError()
+  return new InternalServerError()
 }
 
 const setupPluginCallbacks = (galbe: Galbe) => ({
@@ -37,24 +39,29 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
 
     async fetch(req) {
       if (!METHODS.includes(req.method)) return new Response('', { status: 501 })
+      const cookies: string[] = []
       const context = {
         request: req,
         contentType: !EMPTY_BODY_METHODS.includes(req.method)
-          ? inferBodyType(req.headers.get('content-type'))
+          ? normalizeContentType(req.headers.get('content-type'))
           : undefined,
         remoteAddress: server.requestIP(req),
-        set: { headers: { 'set-cookie': [] } },
+        set: {
+          headers: { 'set-cookie': [] },
+          cookie: (name, value, opt = { path: '/' }) => cookies.push(stringifyCookie(name, value, opt)),
+        },
         state: {},
+        cookies: readCookies(req.headers.get('cookie')),
       } as MakeOptional<Context, 'headers' | 'params' | 'query' | 'body'>
-      for (const p of pluginsCb.onFetch) {
-        //@ts-ignore
-        const r = await p.onFetch(context)
-        if (r) return r
-      }
       const url = new URL(req.url)
       let route: Route
       let response: any = ''
       try {
+        for (const p of pluginsCb.onFetch) {
+          //@ts-ignore
+          const r = await p.onFetch(context)
+          if (r) return r
+        }
         // find route
         try {
           route = router.find(req.method.toLowerCase() as Method, url.pathname)
@@ -84,7 +91,12 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
         }
         let inParams = requestPathParser(url.pathname, route.path)
 
-        context.body = await requestBodyParser(req.body, inHeaders, schema.body, context.contentType)
+        context.body = await requestBodyParser(
+          req.body,
+          inHeaders,
+          EMPTY_BODY_METHODS.includes(req.method) ? undefined : schema.body,
+          context.contentType
+        )
         context.headers = inHeaders
         context.query = inQuery
         context.params = inParams
@@ -152,12 +164,12 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
             context.set.status = response instanceof Response ? response.status : context.set.status || 200
           },
         })
-        if (callChain.length > 1) {
-          let r = await callChain[0].call()
-          if (r) response = r
-        } else response = await handlerWrapper(context as Context)
+        const r = await callChain[0].call()
+        if (r) response = r
+        if (context.set.status === undefined)
+          context.set.status = response instanceof Response ? response.status : 200
 
-        const parsedResponse = responseParser(response, context as Context, schema.response)
+        const parsedResponse = responseParser(response, context as Context, cookies, schema.response)
 
         if (galbe.config?.responseValidator?.enabled !== false && schema.response)
           validateResponse(response, schema.response, parsedResponse.status || 200)
@@ -172,17 +184,19 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
       } catch (error) {
         context.set.status = error instanceof RequestError ? error.status : 500
         let customError
-        for (let eh of galbe.errorCb) customError = responseParser(eh(error, context as Context), context as Context)
+        for (let eh of galbe.errorCb)
+          customError = responseParser(eh(error, context as Context), context as Context, cookies)
         if (customError) return customError
-        if (error instanceof InternalError) {
-          console.log(`Internal Error`, error?.payload || '')
-          return new Response('Internal Server Error', {
+        if (error instanceof InternalServerError) {
+          let internalPayload = 'Internal Server Error'
+          try { internalPayload = JSON.stringify(error?.payload || internalPayload) } catch {}
+          return new Response(internalPayload, {
             status: error.status,
             headers: { 'content-type': 'application/json' },
           })
         } else if (error instanceof RequestError) {
           let payload = error.payload
-          let headers = new Headers(error?.headers || {})
+          let headers = new Headers({ ...context.set.headers, ...error?.headers })
           if (!headers.has('content-type')) {
             if (typeof error.payload === 'string') headers.set('content-type', 'text/plain')
             else {