@toa.io/extensions.exposition 1.0.0-alpha.4 → 1.0.0-alpha.6

package/source/Endpoint.ts

@@ -5,7 +5,7 @@ import { type Context } from './Context'
 import * as http from './HTTP'
 import type * as RTD from './RTD'
 
-export class Endpoint implements RTD.Endpoint<Endpoint> {
+export class Endpoint implements RTD.Endpoint {
   private readonly endpoint: string
   private readonly mapping: Mapping
   private readonly discovery: Promise<Component>
@@ -18,7 +18,9 @@ export class Endpoint implements RTD.Endpoint<Endpoint> {
   }
 
   public async call
-  (body: any, query: http.Query, parameters: RTD.Parameter[]): Promise<http.OutgoingMessage> {
+  (context: http.Context, parameters: RTD.Parameter[]): Promise<http.OutgoingMessage> {
+    const body = await context.body()
+    const query = this.query(context)
     const request = this.mapping.fit(body, query, parameters)
 
     this.remote ??= await this.discovery
@@ -28,14 +30,26 @@ export class Endpoint implements RTD.Endpoint<Endpoint> {
     if (reply instanceof Error)
       throw new http.Conflict(reply)
 
-    const message: http.OutgoingMessage = { body: reply }
+    const message: http.OutgoingMessage = {}
 
     if (typeof reply === 'object' && reply !== null && '_version' in reply) {
+      const etag = context.request.headers['if-none-match']
+
       message.headers ??= new Headers()
-      message.headers.set('etag', `"${reply._version.toString()}"`)
-      delete reply._version
+
+      if (etag !== undefined && reply._version === this.version(etag)) {
+        message.status = 304
+        message.headers.set('etag', etag)
+
+        return message
+      } else {
+        message.headers.set('etag', `"${reply._version.toString()}"`)
+        delete reply._version
+      }
     }
 
+    message.body = reply
+
     return message
   }
 
@@ -44,9 +58,28 @@ export class Endpoint implements RTD.Endpoint<Endpoint> {
 
     await this.remote.disconnect(INTERRUPT)
   }
+
+  private query (context: http.Context): http.Query {
+    const query: http.Query = Object.fromEntries(context.url.searchParams)
+    const etag = context.request.headers['if-match']
+
+    if (etag !== undefined)
+      query.version = this.version(etag)
+
+    return query
+  }
+
+  private version (etag: string): number {
+    const match = etag.match(ETAG)
+
+    if (match === null)
+      throw new http.BadRequest('Invalid ETag.')
+
+    return Number.parseInt(match.groups!.version)
+  }
 }
 
-export class EndpointsFactory implements RTD.EndpointsFactory<Endpoint> {
+export class EndpointsFactory implements RTD.EndpointsFactory {
   private readonly remotes: Remotes
 
   public constructor (remotes: Remotes) {
@@ -70,4 +103,6 @@ export class EndpointsFactory implements RTD.EndpointsFactory<Endpoint> {
   }
 }
 
+const ETAG = /^"(?<version>\d{1,32})"$/
+
 const INTERRUPT = true

package/source/Factory.ts

@@ -3,9 +3,9 @@ import { Gateway } from './Gateway'
 import { Remotes } from './Remotes'
 import { Tree, syntax } from './RTD'
 import { Server } from './HTTP'
-import { type Endpoint, EndpointsFactory } from './Endpoint'
+import { EndpointsFactory } from './Endpoint'
 import { families, interceptors } from './directives'
-import { type Directives, DirectivesFactory } from './Directive'
+import { DirectivesFactory } from './Directive'
 import { Composition } from './Composition'
 import * as root from './root'
 import { Interception } from './Interception'
@@ -29,13 +29,19 @@ export class Factory implements extensions.Factory {
     const debug = process.env.TOA_EXPOSITION_DEBUG === '1'
     const trace = process.env.TOA_EXPOSITION_TRACE === '1'
     const broadcast: Broadcast = this.boot.bindings.broadcast(CHANNEL)
-    const server = Server.create({ methods: syntax.verbs, debug, trace })
+
+    const server = Server.create({
+      methods: syntax.verbs,
+      debug,
+      trace
+    })
+
     const remotes = new Remotes(this.boot)
     const node = root.resolve()
     const methods = new EndpointsFactory(remotes)
     const directives = new DirectivesFactory(families, remotes)
     const interception = new Interception(interceptors)
-    const tree = new Tree<Endpoint, Directives>(node, methods, directives)
+    const tree = new Tree(node, methods, directives)
 
     const composition = new Composition(this.boot)
     const gateway = new Gateway(broadcast, tree, interception)

package/source/Gateway.ts

@@ -5,16 +5,13 @@ import type { Interception } from './Interception'
 import type { Method, Parameter, Tree } from './RTD'
 import type { Label } from './discovery'
 import type { Branch } from './Branch'
-import type { Endpoint } from './Endpoint'
-import type { Directives } from './Directive'
 
 export class Gateway extends Connector {
   private readonly broadcast: Broadcast
-  private readonly tree: Tree<Endpoint, Directives>
+  private readonly tree: Tree
   private readonly interceptor: Interception
 
-  // eslint-disable-next-line max-len
-  public constructor (broadcast: Broadcast, tree: Tree<Endpoint, Directives>, interception: Interception) {
+  public constructor (broadcast: Broadcast, tree: Tree, interception: Interception) {
     super()
 
     this.broadcast = broadcast
@@ -67,8 +64,7 @@ export class Gateway extends Connector {
     console.info('Gateway is closed.')
   }
 
-  private async call
-  (method: Method<Endpoint, Directives>, context: http.Context, parameters: Parameter[]):
+  private async call (method: Method, context: http.Context, parameters: Parameter[]):
   Promise<http.OutgoingMessage> {
     if (context.url.pathname[context.url.pathname.length - 1] !== '/')
       throw new http.NotFound('Trailing slash is required.')
@@ -79,30 +75,11 @@ export class Gateway extends Connector {
     if (method.endpoint === null)
       throw new http.MethodNotAllowed()
 
-    const body = await context.body()
-    const query = this.query(context)
-
     return await method.endpoint
-      .call(body, query, parameters)
+      .call(context, parameters)
       .catch(rethrow) as http.OutgoingMessage
   }
 
-  private query (context: http.Context): http.Query {
-    const query: http.Query = Object.fromEntries(context.url.searchParams)
-    const etag = context.request.headers['if-match']
-
-    if (etag !== undefined) {
-      const match = etag.match(ETAG)
-
-      if (match === null)
-        throw new http.BadRequest('Invalid ETag.')
-      else
-        query.version = parseInt(match.groups!.version)
-    }
-
-    return query
-  }
-
   private async discover (): Promise<void> {
     await this.broadcast.receive<Branch>('expose', this.merge.bind(this))
     await this.broadcast.transmit<null>('ping', null)
@@ -120,6 +97,4 @@ export class Gateway extends Connector {
   }
 }
 
-const ETAG = /^"(?<version>\d{1,32})"$/
-
 export type Broadcast = bindings.Broadcast<Label>

package/source/HTTP/Server.ts

@@ -102,7 +102,7 @@ export class Server extends Connector {
         else
           status = 200
 
-      response.statusCode = status
+      response.statusCode = message.status = status
       write(context, response, message)
     }
   }
@@ -116,7 +116,7 @@ export class Server extends Connector {
         ? exception.status
         : 500
 
-      const message: OutgoingMessage = {}
+      const message: OutgoingMessage = { status: response.statusCode }
       const verbose = exception instanceof ClientError || this.properties.debug
 
       if (verbose)

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

package/source/directives/auth/Authorization.ts

@@ -13,8 +13,7 @@ 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 +26,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 +37,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,
+    assert.ok(name in constructors,
       `Directive '${name}' is not provided by the '${this.name}' family.`)
 
-    const Class = CLASSES[name]
+    const Class = constructors[name]
 
     for (const name of REMOTES)
       this.discovery[name] ??= remotes.discover('identity', name)
@@ -133,7 +132,7 @@ 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,

package/source/directives/cache/Cache.ts

@@ -2,10 +2,10 @@ import { Control } from './Control'
 import { Exact } from './Exact'
 import type { Input, Output } from '../../io'
 import type { Directive } from './types'
-import type { Family } from '../../Directive'
+import type { DirectiveFamily } from '../../RTD'
 import type * as http from '../../HTTP'
 
-export class Cache implements Family<Directive> {
+export class Cache implements DirectiveFamily<Directive> {
   public readonly name: string = 'cache'
   public readonly mandatory: boolean = false
 

package/source/directives/cors/CORS.ts

@@ -3,16 +3,22 @@ import type { Interceptor } from '../../Interception'
 
 export class CORS implements Interceptor {
   public readonly name = 'cors'
-  public readonly mandatory = true
 
-  private readonly allowedHeaders = new Set<string>(['accept', 'authorization', 'content-type'])
+  private readonly requestHeaders = new Set<string>([
+    'accept',
+    'authorization',
+    'content-type',
+    'etag',
+    'if-match',
+    'if-none-match'
+  ])
 
   private readonly headers = new Headers({
     'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE',
     'access-control-allow-credentials': 'true',
-    'access-control-allow-headers': Array.from(this.allowedHeaders).join(', '),
+    'access-control-allow-headers': Array.from(this.requestHeaders).join(', '),
     'access-control-max-age': '3600',
-    'cache-control': 'public, max-age=3600',
+    'cache-control': 'max-age=3600',
     vary: 'origin'
   })
 
@@ -40,9 +46,9 @@ export class CORS implements Interceptor {
     return null
   }
 
-  public allowHeader (header: string): void {
-    this.allowedHeaders.add(header.toLowerCase())
-    this.headers.set('access-control-allow-headers', Array.from(this.allowedHeaders).join(', '))
+  public allow (header: string): void {
+    this.requestHeaders.add(header.toLowerCase())
+    this.headers.set('access-control-allow-headers', Array.from(this.requestHeaders).join(', '))
   }
 
   private preflightResponse (origin: string): Output {

package/source/directives/dev/Development.ts

@@ -2,13 +2,13 @@ import { Stub } from './Stub'
 import { Throw } from './Throw'
 import { type Directive } from './types'
 import type { Input, Output } from '../../io'
-import type { Family } from '../../Directive'
+import type { DirectiveFamily } from '../../RTD'
 
-export class Development implements Family<Directive> {
+export class Development implements DirectiveFamily<Directive> {
   public readonly name: string = 'dev'
   public readonly mandatory: boolean = false
 
-  public create (name: string, value: any): Directive {
+  public create (name: string, value: unknown): Directive {
     const Class = constructors[name]
 
     if (Class === undefined)

package/source/directives/index.ts

@@ -1,11 +1,12 @@
-import { dev } from './dev'
 import { authorization } from './auth'
 import { cache } from './cache'
-import { octets } from './octets'
 import { cors } from './cors'
+import { dev } from './dev'
+import { octets } from './octets'
+import { io } from './io'
 import { vary } from './vary'
-import type { Family } from '../Directive'
+import type { DirectiveFamily } from '../RTD'
 import type { Interceptor } from '../Interception'
 
-export const families: Family[] = [authorization, cache, octets, vary, dev]
+export const families: DirectiveFamily[] = [authorization, io, cache, vary, octets, dev]
 export const interceptors: Interceptor[] = [cors]

package/source/directives/io/Directive.ts

@@ -0,0 +1,11 @@
+import type { Input } from '../../io'
+
+export interface Directive {
+  attach: (context: Input) => void
+}
+
+export interface Constructor {
+  validate: (value: unknown) => void
+
+  new (value: any): Directive
+}

package/source/directives/io/IO.ts

@@ -0,0 +1,43 @@
+import { Output } from './Output'
+import { Input } from './Input'
+import type { Constructor, Directive } from './Directive'
+import type { Input as Context } from '../../io'
+import type { DirectiveFamily } from '../../RTD'
+
+export class IO implements DirectiveFamily<Directive> {
+  public readonly name = 'io'
+  public readonly mandatory = true
+
+  public create (name: string, value: unknown): Directive {
+    if (!(name in constructors))
+      throw new Error(`Directive 'io:${name}' is not implemented.`)
+
+    const Directive = constructors[name]
+
+    Directive.validate(value)
+
+    return new Directive(value)
+  }
+
+  public preflight (directives: Directive[], context: Context): null {
+    let restricted = false
+
+    for (const directive of directives) {
+      restricted ||= directive instanceof Output
+
+      directive.attach(context)
+    }
+
+    if (!restricted)
+      DENIAL.attach(context)
+
+    return null
+  }
+}
+
+const constructors: Record<string, Constructor> = {
+  output: Output,
+  input: Input
+}
+
+const DENIAL: Output = new Output([])