@toa.io/extensions.exposition 1.0.0-alpha.2 → 1.0.0-alpha.21

package/source/HTTP/messages.ts

@@ -1,27 +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 {
-  for (const transform of request.pipelines.response)
+(context: Context, response: http.ServerResponse, message: OutgoingMessage): void {
+  for (const transform of context.pipelines.response)
     transform(message)
 
-  message.headers?.forEach((value, key) => response.set(key, value))
+  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
@@ -30,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)
@@ -40,32 +38,33 @@ export async function read (request: Request): Promise<any> {
   }
 }
 
-function send (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
+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)
-    .append('vary', 'accept')
+    .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)
@@ -73,54 +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
-  subtype: string | null
-  pipelines: {
-    body: Array<(input: unknown) => unknown>
-    response: Array<(output: OutgoingMessage) => void>
-  }
-}
-
 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/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<TDirective = any> {
-  merge: (directive: TDirective) => 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,32 +1,32 @@
-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: [] }
+      return {
+        node: this.trunk,
+        parameters: []
+      }
 
     const fragments = fragment(path)
 
@@ -39,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
@@ -36,7 +33,7 @@ function createRoute (route: syntax.Route, context: Context): Route {
 }
 
 function createMethod (method: syntax.Method, context: Context): Method {
-  const stack = context.directives.stack.concat(method.directives.reverse())
+  const stack = method.directives.concat(context.directives.stack)
   const directives = context.directives.factory.create(stack)
 
   const endpoint = method.mapping?.endpoint === undefined

package/source/Tenant.ts

@@ -25,14 +25,6 @@ export class Tenant extends Connector {
   public override async open (): Promise<void> {
     await this.expose()
     await this.broadcast.receive('ping', this.expose.bind(this))
-
-    console.info('Exposition Tenant for ' +
-      `'${this.branch.namespace}.${this.branch.component}' has started.`)
-  }
-
-  public override async dispose (): Promise<void> {
-    console.info('Exposition Tenant for ' +
-      `'${this.branch.namespace}.${this.branch.component}' has been stopped.`)
   }
 
   private async expose (): Promise<void> {

package/source/deployment.ts

@@ -41,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
   }
 }

package/source/directives/auth/Authorization.ts

@@ -7,14 +7,14 @@ import { Role } from './Role'
 import { Rule } from './Rule'
 import { Incept } from './Incept'
 import { Echo } from './Echo'
-import { split } from './split'
 import { Scheme } from './Scheme'
+import { Delegate } from './Delegate'
+import { split } from './split'
 import { PRIMARY, PROVIDERS } from './schemes'
 import type { Output } from '../../io'
 import type { Component } from '@toa.io/core'
 import type { Remotes } from '../../Remotes'
-import type { Family } from '../../Directive'
-import type { Parameter } from '../../RTD'
+import type { Parameter, DirectiveFamily } from '../../RTD'
 import type {
   AuthenticationResult,
   Ban,
@@ -27,7 +27,7 @@ import type {
   Schemes
 } from './types'
 
-export class Authorization implements Family<Directive, Extension> {
+export class Authorization implements DirectiveFamily<Directive, Extension> {
   public readonly depends: string[] = ['Vary']
   public readonly name: string = 'auth'
   public readonly mandatory: boolean = true
@@ -38,10 +38,10 @@ export class Authorization implements Family<Directive, Extension> {
   private bans: Component | null = null
 
   public create (name: string, value: any, remotes: Remotes): Directive {
-    assert.ok(name in CLASSES,
-      `Directive '${name}' is not provided by the '${this.name}' family.`)
+    assert.ok(name in constructors,
+      `Directive 'auth:${name}' is not implemented.`)
 
-    const Class = CLASSES[name]
+    const Class = constructors[name]
 
     for (const name of REMOTES)
       this.discovery[name] ??= remotes.discover('identity', name)
@@ -56,7 +56,7 @@ export class Authorization implements Family<Directive, Extension> {
   public async preflight (directives: Directive[],
     input: Input,
     parameters: Parameter[]): Promise<Output> {
-    const identity = await this.resolve(input.headers.authorization)
+    const identity = await this.resolve(input.request.headers.authorization)
 
     input.identity = identity
 
@@ -67,8 +67,10 @@ export class Authorization implements Family<Directive, Extension> {
         return directive.reply?.(identity) ?? null
     }
 
-    if (identity === null) throw new http.Unauthorized()
-    else throw new http.Forbidden()
+    if (identity === null)
+      throw new http.Unauthorized()
+    else
+      throw new http.Forbidden()
   }
 
   public async settle (directives: Directive[],
@@ -90,9 +92,9 @@ export class Authorization implements Family<Directive, Extension> {
     const token = await this.tokens.invoke<string>('encrypt', { input: { identity } })
     const authorization = `Token ${token}`
 
-    if (response.headers === undefined) response.headers = new Headers()
-
+    response.headers ??= new Headers()
     response.headers.set('authorization', authorization)
+    response.headers.append('cache-control', 'no-store')
   }
 
   private async resolve (authorization: string | undefined): Promise<Identity | null> {
@@ -131,14 +133,15 @@ export class Authorization implements Family<Directive, Extension> {
   }
 }
 
-const CLASSES: Record<string, new (value: any, argument?: any) => Directive> = {
+const constructors: Record<string, new (value: any, argument?: any) => Directive> = {
   anonymous: Anonymous,
   id: Id,
   role: Role,
   rule: Rule,
   incept: Incept,
   scheme: Scheme,
-  echo: Echo
+  echo: Echo,
+  delegate: Delegate
 }
 
 const REMOTES: Remote[] = ['basic', 'federation', 'tokens', 'roles', 'bans']

package/source/directives/auth/Delegate.ts

@@ -0,0 +1,35 @@
+import { BadRequest } from '../../HTTP'
+import { type Directive, type Identity } from './types'
+import type { Input } from '../../io'
+
+export class Delegate implements Directive {
+  private readonly property: string
+
+  public constructor (property: string) {
+    this.property = property
+  }
+
+  public authorize (identity: Identity | null, context: Input): boolean {
+    if (identity === null)
+      return false
+
+    context.pipelines.body.push((body) => this.embed(body, identity))
+
+    return true
+  }
+
+  private embed (body: unknown, identity: Identity): Record<string, unknown> {
+    if (body === undefined)
+      body = {}
+
+    check(body)
+    body[this.property] = identity
+
+    return body
+  }
+}
+
+function check (body: unknown): asserts body is Record<string, unknown> {
+  if (typeof body !== 'object' || body === null)
+    throw new BadRequest('Invalid request body')
+}

package/source/directives/auth/Incept.ts

@@ -15,28 +15,33 @@ export class Incept implements Directive {
   }
 
   public authorize (identity: Identity | null, input: Input): boolean {
-    return identity === null && 'authorization' in input.headers
+    return identity === null && 'authorization' in input.request.headers
   }
 
-  public async settle (request: Input, response: http.OutgoingMessage): Promise<void> {
+  public async settle (input: Input, response: http.OutgoingMessage): Promise<void> {
     const id = response.body?.[this.property]
 
     if (id === undefined)
       throw new http.Conflict('Identity inception has failed as the response body ' +
         ` does not contain the '${this.property}' property.`)
 
-    const [scheme, credentials] = split(request.headers.authorization!)
+    const [scheme, credentials] = split(input.request.headers.authorization!)
     const provider = PROVIDERS[scheme]
 
     this.schemes[scheme] ??= await this.discovery[provider]
 
     const identity = await this.schemes[scheme]
-      .invoke<Maybe<Identity>>('create', { input: { id, credentials } })
+      .invoke<Maybe<Identity>>('create', {
+      input: {
+        id,
+        credentials
+      }
+    })
 
     if (identity instanceof Error)
       throw new http.Conflict(identity)
 
-    request.identity = identity
-    request.identity.scheme = scheme
+    input.identity = identity
+    input.identity.scheme = scheme
   }
 }