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

package/features/cors.feature

@@ -19,10 +19,10 @@ Feature: CORS Support
       204 No Content
       access-control-allow-origin: https://hello.world
       access-control-allow-methods: GET, POST, PUT, PATCH, DELETE
-      access-control-allow-headers: accept, authorization, content-type
+      access-control-allow-headers: accept, authorization, content-type, etag, if-match, if-none-match
       access-control-allow-credentials: true
       access-control-max-age: 3600
-      cache-control: public, max-age=3600
+      cache-control: max-age=3600
       vary: origin
       """
     When the following request is received:

package/features/etag.feature

@@ -1,6 +1,6 @@
 Feature: Optimistic concurrency control
 
-  Scenario: Receiving `etag`
+  Scenario: Using `etag`
     Given the `pots` is running with the following manifest:
       """yaml
       exposition:
@@ -35,6 +35,16 @@ Feature: Optimistic concurrency control
       200 OK
       etag: "1"
       """
+    When the following request is received:
+      """
+      GET /pots/${{ id }}/ HTTP/1.1
+      if-none-match: "1"
+      """
+    Then the following reply is sent:
+      """
+      304 Not Modified
+      etag: "1"
+      """
     When the following request is received:
       """
       PUT /pots/${{ id }}/ HTTP/1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/extensions.exposition",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.5",
   "description": "Toa Exposition",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -17,9 +17,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@toa.io/core": "1.0.0-alpha.4",
-    "@toa.io/generic": "1.0.0-alpha.4",
-    "@toa.io/schemas": "1.0.0-alpha.4",
+    "@toa.io/core": "1.0.0-alpha.5",
+    "@toa.io/generic": "1.0.0-alpha.5",
+    "@toa.io/schemas": "1.0.0-alpha.5",
     "bcryptjs": "2.4.3",
     "error-value": "0.3.0",
     "js-yaml": "4.1.0",
@@ -43,11 +43,11 @@
     "features": "cucumber-js"
   },
   "devDependencies": {
-    "@toa.io/agent": "1.0.0-alpha.4",
-    "@toa.io/extensions.storages": "1.0.0-alpha.4",
+    "@toa.io/agent": "1.0.0-alpha.5",
+    "@toa.io/extensions.storages": "1.0.0-alpha.5",
     "@types/bcryptjs": "2.4.3",
     "@types/cors": "2.8.13",
     "@types/negotiator": "0.6.1"
   },
-  "gitHead": "80a91c0d9c167484247a91e69a0c0a3c344f90d0"
+  "gitHead": "1e4bb4ac28a6dddff1f4b8c5be7224fcdc47b847"
 }

package/source/Context.ts

@@ -1,6 +1,8 @@
-import { type Endpoint } from './Endpoint'
-import { type Directives } from './Directive'
-import { type Branch } from './Branch'
 import type * as RTD from './RTD'
 
-export type Context = RTD.Context<Endpoint, Directives, Branch>
+export type Context = RTD.Context<Extension>
+
+interface Extension {
+  namespace: string
+  component: string
+}

package/source/Directive.test.ts

@@ -1,11 +1,11 @@
 import assert from 'node:assert'
 import { generate } from 'randomstring'
-import { DirectivesFactory, type Family } from './Directive'
-import { type syntax } from './RTD'
-import { type Remotes } from './Remotes'
+import { DirectivesFactory } from './Directive'
+import type { syntax, DirectiveFamily } from './RTD'
+import type { Remotes } from './Remotes'
 import type { Context } from './HTTP'
 
-const families: Array<jest.MockedObjectDeep<Family>> = [
+const families: Array<jest.MockedObjectDeep<DirectiveFamily>> = [
   {
     name: 'foo',
     mandatory: true,

package/source/Directive.ts

@@ -3,10 +3,10 @@ import type { Remotes } from './Remotes'
 import type { Output } from './io'
 import type * as RTD from './RTD'
 
-export class Directives implements RTD.Directives<Directives> {
-  private readonly sets: DirectiveSet[]
+export class Directives implements RTD.Directives {
+  private readonly sets: RTD.DirectiveSet[]
 
-  public constructor (sets: DirectiveSet[]) {
+  public constructor (sets: RTD.DirectiveSet[]) {
     this.sets = sets
   }
 
@@ -32,18 +32,14 @@ export class Directives implements RTD.Directives<Directives> {
       if (set.family.settle !== undefined)
         await set.family.settle(set.directives, context, response)
   }
-
-  public merge (directives: Directives): void {
-    this.sets.push(...directives.sets)
-  }
 }
 
-export class DirectivesFactory implements RTD.DirectivesFactory<Directives> {
+export class DirectivesFactory implements RTD.DirectiveFactory {
   private readonly remotes: Remotes
-  private readonly families: Record<string, Family> = {}
+  private readonly families: Record<string, RTD.DirectiveFamily> = {}
   private readonly mandatory: string[] = []
 
-  public constructor (families: Family[], remotes: Remotes) {
+  public constructor (families: RTD.DirectiveFamily[], remotes: Remotes) {
     for (const family of families) {
       this.families[family.name] = family
 
@@ -74,7 +70,7 @@ export class DirectivesFactory implements RTD.DirectivesFactory<Directives> {
       mandatory.delete(family.name)
     }
 
-    const sets: DirectiveSet[] = []
+    const sets: RTD.DirectiveSet[] = []
 
     for (const family of mandatory)
       sets.push({
@@ -99,25 +95,3 @@ export const shortcuts: RTD.syntax.Shortcuts = new Map([
   ['rule', 'auth:rule'],
   ['incept', 'auth:incept']
 ])
-
-export interface Family<TDirective = any, TExtension = any> {
-  readonly name: string
-  readonly mandatory: boolean
-
-  // produce: (declarations: RTD.syntax.Directive[], remotes: Remotes) => TDirective[]
-
-  create: (name: string, value: any, remotes: Remotes) => TDirective
-
-  preflight?: (directives: TDirective[],
-    request: Context & TExtension,
-    parameters: RTD.Parameter[]) => Output | Promise<Output>
-
-  settle?: (directives: TDirective[],
-    request: Context & TExtension,
-    response: OutgoingMessage) => void | Promise<void>
-}
-
-interface DirectiveSet {
-  family: Family
-  directives: any[]
-}

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/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

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