@toa.io/extensions.exposition 1.0.0-alpha.0 → 1.0.0-alpha.11

package/source/HTTP/messages.ts

@@ -1,22 +1,26 @@
-import { type IncomingHttpHeaders } from 'node:http'
 import { Readable } from 'node:stream'
-import { type Request, type Response } from 'express'
-import { buffer } from '@toa.io/streams'
+import { buffer } from 'node:stream/consumers'
 import { formats } from './formats'
 import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions'
-import type { ParsedQs } from 'qs'
-import type { Format } from './formats'
+import type { Context } from './Context'
+import type * as http from 'node:http'
 
 export function write
-(request: IncomingMessage, response: Response, message: OutgoingMessage): void {
+(context: Context, response: http.ServerResponse, message: OutgoingMessage): void {
+  for (const transform of context.pipelines.response)
+    transform(message)
+
+  message.headers?.forEach((value, key) => response.setHeader(key, value))
+  context.timing.append(response)
+
   if (message.body instanceof Readable)
-    stream(message, request, response)
+    stream(message, context, response)
   else
-    send(message, request, response)
+    send(message, context, response)
 }
 
-export async function read (request: Request): Promise<any> {
-  const type = request.headers['content-type']
+export async function read (context: Context): Promise<any> {
+  const type = context.request.headers['content-type']
 
   if (type === undefined)
     return undefined
@@ -25,8 +29,7 @@ export async function read (request: Request): Promise<any> {
     throw new UnsupportedMediaType()
 
   const format = formats[type]
-
-  const buf = await buffer(request)
+  const buf = await context.timing.capture('buffer', buffer(context.request))
 
   try {
     return format.decode(buf)
@@ -35,30 +38,33 @@ export async function read (request: Request): Promise<any> {
   }
 }
 
-function send (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
-  if (message.body === undefined) {
+function send
+(message: OutgoingMessage, context: Context, response: http.ServerResponse): void {
+  if (message.body === undefined || message.body === null) {
     response.end()
 
     return
   }
 
-  if (request.encoder === null)
+  if (context.encoder === null)
     throw new NotAcceptable()
 
-  const buf = request.encoder.encode(message.body)
+  const buf = context.encoder.encode(message.body)
 
-  response.set('content-type', request.encoder.type)
-  response.end(buf)
+  response
+    .setHeader('content-type', context.encoder.type)
+    .appendHeader('vary', 'accept')
+    .end(buf)
 }
 
 function stream
-(message: OutgoingMessage, request: IncomingMessage, response: Response): void {
+(message: OutgoingMessage, context: Context, response: http.ServerResponse): void {
   const encoded = message.headers !== undefined && message.headers.has('content-type')
 
   if (encoded)
-    pipe(message, response)
+    message.body.pipe(response)
   else
-    multipart(message, request, response)
+    multipart(message, context, response)
 
   message.body.on('error', (e: Error) => {
     console.error(e)
@@ -66,49 +72,39 @@ function stream
   })
 }
 
-function pipe (message: OutgoingMessage, response: Response): void {
-  message.headers?.forEach((value, key) => response.set(key, value))
-  message.body.pipe(response)
-}
-
-function multipart (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
-  if (request.encoder === null)
+function multipart
+(message: OutgoingMessage, context: Context, response: http.ServerResponse): void {
+  if (context.encoder === null)
     throw new NotAcceptable()
 
-  const encoder = request.encoder
+  const encoder = context.encoder
 
-  response.set('content-type', `${encoder.multipart}; boundary=${BOUNDARY}`)
+  response.setHeader('content-type', `${encoder.multipart}; boundary=${BOUNDARY}`)
 
   message.body
-    .map((part: unknown) => Buffer.concat([CUT, encoder.encode(part)]))
+    .map((part: unknown) => Buffer.concat([CUT, encoder.encode(part), CRLF]))
     .on('end', () => response.end(FINALCUT))
     .pipe(response)
 }
 
 const BOUNDARY = 'cut'
 const CUT = Buffer.from(`--${BOUNDARY}\r\n`)
+const CRLF = Buffer.from('\r\n')
 const FINALCUT = Buffer.from(`--${BOUNDARY}--`)
 
-export interface IncomingMessage extends Request {
-  method: string
-  path: string
-  url: string
-  headers: IncomingHttpHeaders
-  query: Query
-  parse: <T> () => Promise<T>
-  encoder: Format | null
-}
-
 export interface OutgoingMessage {
   status?: number
   headers?: Headers
   body?: any
 }
 
-export interface Query extends ParsedQs {
+export interface Query {
+  [key: string]: string | number | undefined
+
   id?: string
   criteria?: string
   sort?: string
   omit?: string
   limit?: string
+  version?: number
 }

package/source/Interception.ts

@@ -0,0 +1,24 @@
+import type { Input, Output } from './io'
+
+export class Interception implements Interceptor {
+  private readonly interceptors: Interceptor[]
+
+  public constructor (interceptors: Interceptor[]) {
+    this.interceptors = interceptors
+  }
+
+  public async intercept (input: Input): Promise<Output> {
+    for (const interceptor of this.interceptors) {
+      const output = await interceptor.intercept(input)
+
+      if (output !== null)
+        return output
+    }
+
+    return null
+  }
+}
+
+export interface Interceptor {
+  intercept: (input: Input) => Output | Promise<Output>
+}

package/source/Mapping.ts

@@ -29,7 +29,10 @@ class QueryableMapping extends Mapping {
   public fit (input: any, qs: http.Query, parameters: Parameter[]): core.Request {
     const query = this.query.fit(qs, parameters)
 
-    return { input, query }
+    return {
+      input,
+      query
+    }
   }
 }
 
@@ -38,14 +41,10 @@ class InputMapping extends Mapping {
     if (input === undefined && parameters.length > 0)
       input = {}
 
-    if (typeof input === 'object')
-      this.assign(input, parameters)
+    if (typeof input === 'object' && input !== null)
+      for (const parameter of parameters)
+        input[parameter.name] = parameter.value
 
     return { input }
   }
-
-  private assign (input: Record<string, any>, parameters: Parameter[]): void {
-    for (const parameter of parameters)
-      input[parameter.name] = parameter.value
-  }
 }

package/source/RTD/Context.ts

@@ -1,16 +1,13 @@
-import { type Directives, type DirectivesFactory } from './Directives'
-import { type Endpoint, type EndpointsFactory } from './Endpoint'
+import { type DirectiveFactory } from './Directives'
+import { type EndpointsFactory } from './Endpoint'
+import type { Directive } from './syntax'
 
-export interface Context<
-  TEndpoint extends Endpoint = any,
-  TDirectives extends Directives<TDirectives> = any,
-  TExtension = any
-> {
+export interface Context<TExtension = any> {
   readonly protected: boolean
-  readonly endpoints: EndpointsFactory<TEndpoint>
+  readonly endpoints: EndpointsFactory
   readonly directives: {
-    readonly factory: DirectivesFactory
-    stack: TDirectives[]
+    readonly factory: DirectiveFactory
+    stack: Directive[]
   }
   readonly extension?: TExtension
 }

package/source/RTD/Directives.ts

@@ -1,9 +1,33 @@
+import type { Parameter } from './Match'
 import type * as syntax from './syntax'
+import type { Context, OutgoingMessage } from '../HTTP'
+import type { Output } from '../io'
 
-export interface Directives<T = any> {
-  merge: (directive: T) => void
+export interface Directives {
+  preflight: (context: Context, parameters: Parameter[]) => Promise<Output>
+  settle: (context: Context, response: OutgoingMessage) => Promise<void>
 }
 
-export interface DirectivesFactory<T = any> {
-  create: (directives: syntax.Directive[]) => T
+export interface DirectiveFactory {
+  create: (directives: syntax.Directive[]) => Directives
+}
+
+export interface DirectiveSet {
+  family: DirectiveFamily
+  directives: any[]
+}
+
+export interface DirectiveFamily<TDirective = any, TExtension = any> {
+  readonly name: string
+  readonly mandatory: boolean
+
+  create: (name: string, ...rest: any[]) => TDirective
+
+  preflight?: (directives: TDirective[],
+    request: Context & TExtension,
+    parameters: Parameter[]) => Output | Promise<Output>
+
+  settle?: (directives: TDirective[],
+    request: Context & TExtension,
+    response: OutgoingMessage) => void | Promise<void>
 }

package/source/RTD/Endpoint.ts

@@ -1,11 +1,13 @@
 import { type Context } from './Context'
+import type * as http from '../HTTP'
 import type * as syntax from './syntax'
+import type * as RTD from './index'
 
-export interface Endpoint<T extends Endpoint = any> {
-  call: T['call']
+export interface Endpoint {
+  call: (context: http.Context, parameters: RTD.Parameter[]) => Promise<http.OutgoingMessage>
   close: () => Promise<void>
 }
 
-export interface EndpointsFactory<T extends Endpoint<T> = any> {
-  create: (method: syntax.Method, context: Context) => T
+export interface EndpointsFactory {
+  create: (method: syntax.Method, context: Context) => Endpoint
 }

package/source/RTD/Match.ts

@@ -1,12 +1,7 @@
 import { type Node } from './Node'
-import { type Directives } from './Directives'
-import { type Endpoint } from './Endpoint'
 
-export interface Match<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
-  node: Node<TEndpoint, TDirectives>
+export interface Match {
+  node: Node
   parameters: Parameter[]
 }
 

package/source/RTD/Method.ts

@@ -1,14 +1,11 @@
-import { type Directives } from './Directives'
-import { type Endpoint } from './Endpoint'
+import type { Endpoint } from './Endpoint'
+import type { Directives } from './Directives'
 
-export class Method<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
-  public readonly endpoint: TEndpoint | null
-  public readonly directives: TDirectives
+export class Method {
+  public readonly endpoint: Endpoint | null
+  public readonly directives: Directives
 
-  public constructor (endpoint: TEndpoint | null, directives: TDirectives) {
+  public constructor (endpoint: Endpoint | null, directives: Directives) {
     this.endpoint = endpoint
     this.directives = directives
   }
@@ -18,7 +15,4 @@ export class Method<
   }
 }
 
-export type Methods<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> = Record<string, Method<TEndpoint, TDirectives>>
+export type Methods = Record<string, Method>

package/source/RTD/Node.ts

@@ -1,20 +1,15 @@
 import { type Route } from './Route'
 import { type Methods } from './Method'
 import { type Match, type Parameter } from './Match'
-import { type Directives } from './Directives'
-import { type Endpoint } from './Endpoint'
 
-export class Node<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
+export class Node {
   public intermediate: boolean
-  public methods: Methods<TEndpoint, TDirectives>
+  public methods: Methods
   private readonly protected: boolean
   private routes: Route[]
 
   public constructor
-  (routes: Route[], methods: Methods<TEndpoint, TDirectives>, properties: Properties) {
+  (routes: Route[], methods: Methods, properties: Properties) {
     this.routes = routes
     this.methods = methods
     this.protected = properties.protected
@@ -34,26 +29,30 @@ export class Node<
     return null
   }
 
-  public merge (node: Node<TEndpoint, TDirectives>): void {
+  public merge (node: Node): void {
     this.intermediate = node.intermediate
 
-    if (!this.protected) this.replace(node)
-    else this.append(node)
+    if (!this.protected)
+      this.replace(node)
+    else
+      this.append(node)
 
     this.sort()
   }
 
-  private replace (node: Node<TEndpoint, TDirectives>): void {
+  private replace (node: Node): void {
     const methods = Object.values(this.methods)
 
     this.routes = node.routes
     this.methods = node.methods
 
     for (const method of methods)
-      void method.close() // race condition is really unlikely
+      void method.close()
+
+    // race condition is really unlikely
   }
 
-  private append (node: Node<TEndpoint, TDirectives>): void {
+  private append (node: Node): void {
     for (const route of node.routes)
       this.mergeRoute(route)
 

package/source/RTD/Tree.ts

@@ -1,30 +1,33 @@
-import { type Node } from './Node'
 import { createNode } from './factory'
 import { fragment } from './segment'
-import { type Match } from './Match'
-import { type Context } from './Context'
-import { type Directives, type DirectivesFactory } from './Directives'
-import { type Endpoint, type EndpointsFactory } from './Endpoint'
+import type { Node } from './Node'
+import type { Match } from './Match'
+import type { Context } from './Context'
+import type { DirectiveFactory } from './Directives'
+import type { EndpointsFactory } from './Endpoint'
 import type * as syntax from './syntax'
 
-export class Tree<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
+export class Tree {
   private readonly root: syntax.Node
-  private readonly trunk: Node<TEndpoint, TDirectives>
-  private readonly endpoints: EndpointsFactory<TEndpoint>
-  private readonly directives: DirectivesFactory
+  private readonly trunk: Node
+  private readonly endpoints: EndpointsFactory
+  private readonly directives: DirectiveFactory
 
   public constructor
-  (node: syntax.Node, endpoints: EndpointsFactory, directives: DirectivesFactory) {
+  (node: syntax.Node, endpoints: EndpointsFactory, directives: DirectiveFactory) {
     this.endpoints = endpoints
     this.directives = directives
     this.trunk = this.createNode(node, PROTECTED)
     this.root = node
   }
 
-  public match (path: string): Match<TEndpoint, TDirectives> | null {
+  public match (path: string): Match | null {
+    if (path === '/')
+      return {
+        node: this.trunk,
+        parameters: []
+      }
+
     const fragments = fragment(path)
 
     return this.trunk.match(fragments)
@@ -36,7 +39,8 @@ export class Tree<
     this.trunk.merge(branch)
   }
 
-  private createNode (node: syntax.Node, protect: boolean, extension?: any): Node {
+  private createNode
+  (node: syntax.Node, protect: boolean, extension?: any): Node {
     const context: Context = {
       protected: protect,
       endpoints: this.endpoints,

package/source/RTD/factory.ts

@@ -1,14 +1,11 @@
 import { Node, type Properties } from './Node'
 import { Route } from './Route'
-import { type Context } from './Context'
 import { segment } from './segment'
 import { Method, type Methods } from './Method'
-import { type Endpoint } from './Endpoint'
-import { type Directives } from './Directives'
+import type { Context } from './Context'
 import type * as syntax from './syntax'
 
-export function createNode<TEndpoint extends Endpoint, TDirectives extends Directives>
-(node: syntax.Node, context: Context): Node<TEndpoint, TDirectives> {
+export function createNode (node: syntax.Node, context: Context): Node {
   if (node.isolated === true)
     context.directives.stack = node.directives
   else

package/source/RTD/syntax/parse.ts

@@ -28,7 +28,7 @@ function parseNode (input: object, shortcuts?: Shortcuts): Node {
     }
 
     if (key[0] === '/') {
-      const route = parseRoute(key, value, shortcuts)
+      const route = parseRoute(key, value as Node, shortcuts)
 
       node.routes.push(route)
 
@@ -36,7 +36,7 @@ function parseNode (input: object, shortcuts?: Shortcuts): Node {
     }
 
     if (verbs.has(key)) {
-      const method = parseMethod(key, value, shortcuts)
+      const method = parseMethod(key, value as Mapping, shortcuts)
 
       node.methods.push(method)
 
@@ -65,7 +65,7 @@ export function createNode (): Node {
   }
 }
 
-function parseRoute (path: string, value: object, shortcuts?: Shortcuts): Route {
+function parseRoute (path: string, value: Node, shortcuts?: Shortcuts): Route {
   const node = parse(value, shortcuts)
 
   return createRoute(path, node)
@@ -106,10 +106,10 @@ function parseQuery (mapping: any): void {
     return
 
   if (typeof query.limit === 'number')
-    query.limit = expandRange(query.limit)
+    query.limit = expandRange(query.limit as number)
 
   if (typeof query.omit === 'number')
-    query.omit = expandRange(query.omit)
+    query.omit = expandRange(query.omit as number)
 }
 
 function parseDirectives (mapping: Record<string, any>, shortcuts?: Shortcuts): Directive[] {
@@ -132,7 +132,7 @@ function parseDirectives (mapping: Record<string, any>, shortcuts?: Shortcuts):
 
 function parseDirective (key: string, value: any, shortcuts?: Shortcuts): Directive | null {
   if (shortcuts?.has(key) === true)
-    key = shortcuts.get(key) as string
+    key = shortcuts.get(key)! // eslint-disable-line @typescript-eslint/no-non-null-assertion
 
   const match = key.match(DIRECTIVE_RX)
 

package/source/RTD/syntax/types.ts

@@ -45,4 +45,4 @@ export interface Range {
   range: [number, number]
 }
 
-export const verbs = new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'])
+export const verbs = new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'])

package/source/deployment.ts

@@ -27,8 +27,7 @@ export function deployment (_: unknown, annotation: Annotation | undefined): Dep
     }
 
   if (annotation?.['/'] !== undefined) {
-    const node = { '/': annotation['/'] }
-    const tree = parse(node, shortcuts)
+    const tree = parse(annotation['/'], shortcuts)
 
     service.variables.push({
       name: 'TOA_EXPOSITION',
@@ -42,6 +41,12 @@ export function deployment (_: unknown, annotation: Annotation | undefined): Dep
       value: '1'
     })
 
+  if (annotation?.trace === true)
+    service.variables.push({
+      name: 'TOA_EXPOSITION_TRACE',
+      value: '1'
+    })
+
   if (annotation !== undefined)
     schemas.annotaion.validate(annotation)
 

package/source/directives/auth/Anonymous.ts

@@ -8,7 +8,8 @@ export class Anonymous implements Directive {
   }
 
   public authorize (_: any, input: Input): boolean {
-    if ('authorization' in input.headers) return false
-    else return this.allow
+    return 'authorization' in input.request.headers
+      ? false
+      : this.allow
   }
 }