@toa.io/extensions.exposition 1.0.0-alpha.3 → 1.0.0-alpha.30

package/source/directives/octets/Store.ts

@@ -4,6 +4,7 @@ import { BadRequest, UnsupportedMediaType } from '../../HTTP'
 import { cors } from '../cors'
 import * as schemas from './schemas'
 import { Workflow } from './workflows'
+import { Directive } from './Directive'
 import type { Readable } from 'stream'
 import type { Parameter } from '../../RTD'
 import type { Unit } from './workflows'
@@ -12,9 +13,9 @@ import type { Remotes } from '../../Remotes'
 import type { ErrorType } from 'error-value'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io'
-import type { Directive, Input } from './types'
+import type { Input } from './types'
 
-export class Store implements Directive {
+export class Store extends Directive {
   public readonly targeted = false
 
   private readonly accept?: string
@@ -24,6 +25,7 @@ export class Store implements Directive {
 
   public constructor
   (options: Options | null, discovery: Promise<Component>, remotes: Remotes) {
+    super()
     schemas.store.validate(options)
 
     this.accept = match(options?.accept,
@@ -36,45 +38,51 @@ export class Store implements Directive {
 
     this.discovery.storage = discovery
 
-    cors.allowHeader('content-meta')
+    cors.allow('content-meta')
   }
 
-  public async apply (storage: string, request: Input, parameters: Parameter[]): Promise<Output> {
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
     this.storage ??= await this.discovery.storage
 
-    const input: StoreInput = { storage, request }
-    const meta = request.headers['content-meta']
+    const request: StoreRequest = {
+      input: {
+        storage,
+        request: input.request
+      }
+    }
+
+    const meta = input.request.headers['content-meta']
 
     if (this.accept !== undefined)
-      input.accept = this.accept
+      request.input.accept = this.accept
 
     if (meta !== undefined)
-      input.meta = this.parseMeta(meta)
+      request.input.meta = this.parseMeta(meta)
 
-    const entry = await this.storage.invoke<Entry>('store', { input })
+    const entry = await this.storage.invoke<Entry>('store', request)
 
     return match<Output>(entry,
       Error, (error: ErrorType) => this.throw(error),
-      () => this.reply(request, storage, entry, parameters))
+      () => this.reply(input, storage, entry, parameters))
   }
 
   // eslint-disable-next-line max-params
-  private reply (request: Input, storage: string, entry: Entry, parameters: Parameter[]): Output {
+  private reply (input: Input, storage: string, entry: Entry, parameters: Parameter[]): Output {
     const body = this.workflow === undefined
       ? entry
-      : this.execute(request, storage, entry, parameters)
+      : this.execute(input, storage, entry, parameters)
 
     return { body }
   }
 
   // eslint-disable-next-line max-params
   private execute
-  (request: Input, storage: string, entry: Entry, parameters: Parameter[]): Readable {
+  (input: Input, storage: string, entry: Entry, parameters: Parameter[]): Readable {
     const stream = new PassThrough({ objectMode: true })
 
     stream.push(entry)
 
-    this.workflow!.execute(request, storage, entry, parameters).pipe(stream)
+    this.workflow!.execute(input, storage, entry, parameters).pipe(stream)
 
     return stream
   }
@@ -108,9 +116,11 @@ export interface Options {
   workflow?: Unit[] | Unit
 }
 
-interface StoreInput {
-  storage: string
-  request: Input
-  accept?: string
-  meta?: Record<string, string>
+interface StoreRequest {
+  input: {
+    storage: string
+    request: Input['request']
+    accept?: string
+    meta?: Record<string, string>
+  }
 }

package/source/directives/octets/Workflow.ts

@@ -1,8 +1,9 @@
 import { NotFound } from '../../HTTP'
 import * as schemas from './schemas'
 import { Workflow } from './workflows'
+import { Directive } from './Directive'
 import type { Unit } from './workflows'
-import type { Directive, Input } from './types'
+import type { Input } from './types'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io'
 import type { Remotes } from '../../Remotes'
@@ -10,7 +11,7 @@ import type { Maybe } from '@toa.io/types'
 import type { Entry } from '@toa.io/extensions.storages'
 import type { Parameter } from '../../RTD'
 
-export class WorkflowDirective implements Directive {
+export class WorkflowDirective extends Directive {
   public readonly targeted = true
 
   private readonly workflow: Workflow
@@ -18,24 +19,30 @@ export class WorkflowDirective implements Directive {
   private storage: Component | null = null
 
   public constructor (units: Unit[] | Unit, discovery: Promise<Component>, remotes: Remotes) {
+    super()
     schemas.workflow.validate(units)
 
     this.workflow = new Workflow(units, remotes)
     this.discovery = discovery
   }
 
-  public async apply (storage: string, request: Input, parameters: Parameter[]): Promise<Output> {
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
     this.storage ??= await this.discovery
 
     const entry = await this.storage.invoke<Maybe<Entry>>('get',
-      { input: { storage, path: request.url } })
+      {
+        input: {
+          storage,
+          path: input.request.url
+        }
+      })
 
     if (entry instanceof Error)
       throw new NotFound()
 
     return {
       status: 202,
-      body: this.workflow.execute(request, storage, entry, parameters)
+      body: this.workflow.execute(input, storage, entry, parameters)
     }
   }
 }

package/source/directives/octets/types.ts

@@ -1,12 +1,5 @@
-import type { Parameter } from '../../RTD'
 import type * as io from '../../io'
 
-export interface Directive {
-  readonly targeted: boolean
-
-  apply: (storage: string, input: Input, parameters: Parameter[]) => io.Output | Promise<io.Output>
-}
-
 export interface Extension {
   octets?: string
 }

package/source/directives/octets/workflows/Workflow.ts

@@ -21,8 +21,8 @@ export class Workflow {
 
   // eslint-disable-next-line max-params
   public execute
-  (request: Input, storage: string, entry: Entry, params: Parameter[]): Execution {
-    const path = posix.join(request.path, entry.id)
+  (input: Input, storage: string, entry: Entry, params: Parameter[]): Execution {
+    const path = posix.join(input.request.url, entry.id)
     const parameters: Record<string, string> = {}
 
     for (const { name, value } of params)

package/source/directives/require/Directive.ts

@@ -0,0 +1,5 @@
+import type { Input } from '../../io'
+
+export interface Directive {
+  preflight: (context: Input) => void
+}

package/source/directives/require/Headers.ts

@@ -0,0 +1,20 @@
+import { BadRequest } from '../../HTTP'
+import type { Input } from '../../io'
+import type { Directive } from './Directive'
+
+export class Headers implements Directive {
+  private readonly headers: string[]
+
+  public constructor (headers: string[]) {
+    if (!Array.isArray(headers))
+      headers = [headers]
+
+    this.headers = headers
+  }
+
+  public preflight (context: Input): void {
+    for (const header of this.headers)
+      if (context.request.headers[header] === undefined)
+        throw new BadRequest(`Header required: ${header}`)
+  }
+}

package/source/directives/require/Require.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert'
+import { Headers } from './Headers'
+import type { Input } from '../../io'
+import type { Directive } from './Directive'
+import type { DirectiveFamily } from '../../RTD'
+
+export class Require implements DirectiveFamily {
+  public readonly name = 'require'
+  public readonly mandatory = false
+
+  public create (name: string, value: unknown): Directive {
+    assert.ok(name in directives, `Unknown directive: require:${name}`)
+
+    return new directives[name](value)
+  }
+
+  public preflight (instances: Directive[], context: Input): null {
+    for (const instance of instances)
+      instance.preflight(context)
+
+    return null
+  }
+}
+
+const directives: Record<string, new (value: any) => Directive> = {
+  header: Headers,
+  headers: Headers
+}

package/source/directives/require/index.ts

@@ -0,0 +1,3 @@
+import { Require } from './Require'
+
+export const req = new Require()

package/source/directives/vary/Directive.ts

@@ -1,6 +1,7 @@
 import type { Properties } from './Properties'
 import type { Input } from '../../io'
+import type { Parameter } from '../../RTD'
 
 export interface Directive {
-  preflight: (request: Input, properties: Properties) => void
+  preflight: (context: Input, properties: Properties, parameters: Parameter[]) => void
 }

package/source/directives/vary/Embed.ts

@@ -1,9 +1,10 @@
 import assert from 'node:assert'
-import { Header, embeddings } from './embeddings'
+import { Header, embeddings, Parameter } from './embeddings'
 import type { Embedding } from './embeddings'
 import type { Input } from '../../io'
 import type { Directive } from './Directive'
 import type { Properties } from './Properties'
+import type * as RTD from '../../RTD'
 
 export class Embed implements Directive {
   private readonly embeddings: Array<[string, Embedding[]]> = []
@@ -16,6 +17,9 @@ export class Embed implements Directive {
         if (name[0] === ':')
           return new Header(name.slice(1))
 
+        if (name.slice(0, 2) === '/:')
+          return new Parameter(name.slice(2))
+
         assert.ok(name in embeddings, `Unknown embedding: ${name}`)
 
         return new embeddings[name]()
@@ -25,27 +29,29 @@ export class Embed implements Directive {
     }
   }
 
-  public preflight (input: Input, properties: Properties): void {
+  public preflight (context: Input, properties: Properties, parameters: RTD.Parameter[]): void {
     const values: Record<string, unknown> = {}
 
     for (const [key, instances] of this.embeddings)
-      values[key] = this.resolve(instances, input, properties)
+      values[key] = this.resolve(instances, context, properties, parameters)
 
-    input.pipelines.body.push(this.embedding(values))
+    context.pipelines.body.push(this.embedding(values))
   }
 
-  private resolve (instances: Embedding[], input: Input, properties: Properties): unknown {
+  // eslint-disable-next-line max-params
+  private resolve (instances: Embedding[],
+    input: Input,
+    properties: Properties,
+    parameters: RTD.Parameter[]): unknown {
     let value
 
     for (const instance of instances) {
-      value = instance.resolve(input, properties)
+      value = instance.resolve(input, properties, parameters)
 
       if (value !== undefined)
         break
     }
 
-    assert.ok(value !== undefined, 'Neither embedding resolved a value.')
-
     return value
   }
 

package/source/directives/vary/Vary.ts

@@ -3,10 +3,10 @@ import { properties, Property } from './Properties'
 import { Embed } from './Embed'
 import type { Properties } from './Properties'
 import type { Directive } from './Directive'
-import type { Family } from '../../Directive'
+import type { DirectiveFamily, Parameter } from '../../RTD'
 import type { Input, Output } from '../../io'
 
-export class Vary implements Family {
+export class Vary implements DirectiveFamily {
   public readonly name = 'vary'
   public readonly mandatory = false
 
@@ -15,13 +15,15 @@ export class Vary implements Family {
       () => name in properties, (name: PN) => new Property(name, value as PV),
       () => name in directives, (name: keyof typeof directives) => new directives[name](value),
       () => {
-        throw new Error(`Unknown directive 'vary:${name}'`)
+        throw new Error(`Directive 'vary:${name}' is not implemented.`)
       })
   }
 
-  public preflight (instances: Array<Directive | Property>, request: Input): Output {
+  public preflight (instances: Array<Directive | Property>,
+    context: Input,
+    parameters: Parameter[]): Output {
     /*
-    To stop consructing `properties` object on each request, Directive Families must be refactored
+    To stop constructing `properties` object on each request, Directive Families must be refactored
     from singleton factories to per-Node instances on the Tree.
      */
     const properties: Properties = {}
@@ -34,7 +36,7 @@ export class Vary implements Family {
         directives.push(instance)
 
     for (const directive of directives)
-      directive.preflight(request, properties)
+      directive.preflight(context, properties, parameters)
 
     return null
   }

package/source/directives/vary/embeddings/Authority.ts

@@ -0,0 +1,8 @@
+import type { Embedding } from './Embedding'
+import type { Input } from '../../../io'
+
+export class Authority implements Embedding {
+  public resolve (context: Input): string {
+    return context.authority
+  }
+}

package/source/directives/vary/embeddings/Embedding.ts

@@ -1,6 +1,7 @@
 import type { Properties } from '../Properties'
 import type { Input } from '../../../io'
+import type { Parameter } from '../../../RTD'
 
 export interface Embedding {
-  resolve: (input: Input, properties: Properties) => string | undefined
+  resolve: (input: Input, properties: Properties, parameters: Parameter[]) => string | undefined
 }

package/source/directives/vary/embeddings/Header.ts

@@ -6,21 +6,23 @@ export class Header implements Embedding {
   private readonly name: string
 
   public constructor (name: string) {
-    this.name = name
+    this.name = name.toLowerCase()
 
-    cors.allowHeader(this.name)
+    if (this.name !== 'host')
+      cors.allow(this.name)
   }
 
   public resolve (input: Input): string | undefined {
-    const value = input.headers[this.name]
+    const value = input.request.headers[this.name]
 
     if (value === undefined)
       return value
 
-    input.pipelines.response.push((response) => {
-      response.headers ??= new Headers()
-      response.headers.append('vary', this.name)
-    })
+    if (this.name !== 'host')
+      input.pipelines.response.push((response) => {
+        response.headers ??= new Headers()
+        response.headers.append('vary', this.name)
+      })
 
     if (Array.isArray(value))
       return value.join(', ')

package/source/directives/vary/embeddings/Language.ts

@@ -7,7 +7,7 @@ import type { Input } from '../../../io'
 
 export class Language implements Embedding {
   public constructor () {
-    cors.allowHeader('accept-language')
+    cors.allow('accept-language')
   }
 
   public resolve (input: Input, properties: Properties): string | undefined {
@@ -17,7 +17,7 @@ export class Language implements Embedding {
     assert.ok(properties.languages.length > 0,
       'List of supported languages is empty.')
 
-    const negotiator = new Negotiator(input)
+    const negotiator = new Negotiator(input.request)
     const language = negotiator.language(properties.languages) ?? properties.languages[0]
 
     input.pipelines.response.push((response) => {

package/source/directives/vary/embeddings/Parameter.ts

@@ -0,0 +1,14 @@
+import type { Embedding } from './Embedding'
+import type * as RTD from '../../../RTD'
+
+export class Parameter implements Embedding {
+  private readonly name: string
+
+  public constructor (name: string) {
+    this.name = name
+  }
+
+  public resolve (_: unknown, __: unknown, parameters: RTD.Parameter[]): string | undefined {
+    return parameters.find((parameter) => parameter.name === this.name)?.value
+  }
+}

package/source/directives/vary/embeddings/index.ts

@@ -1,11 +1,13 @@
 import { Language } from './Language'
-import { Header } from './Header'
-
+import { Authority } from './Authority'
 import type { Embedding } from './Embedding'
 
 export const embeddings: Record<string, new () => Embedding> = {
-  language: Language
+  language: Language,
+  authority: Authority
 }
 
-export { Header }
 export type { Embedding }
+
+export { Header } from './Header'
+export { Parameter } from './Parameter'

package/source/exceptions.ts

@@ -1,17 +1,28 @@
-import { type Exception } from '@toa.io/core'
+import { match } from 'matchacho'
 import * as http from './HTTP'
+import { Exception as HTTPException } from './HTTP'
+import type { Exception } from '@toa.io/core'
 
-export function rethrow (exception: Exception): void {
-  // see /runtime/core/src/exceptions.js
-
-  if ((exception.code >= 200 && exception.code < 210) || exception.code === 221)
-    throw new http.BadRequest(exception.message)
+export function rethrow (exception: Exception | HTTPException): void {
+  if (exception instanceof HTTPException)
+    throw exception
 
-  if (exception.code === 302)
-    throw new http.NotFound()
+  // see /runtime/core/src/exceptions.js
+  throw match(exception.code,
+    badRequest, () => new http.BadRequest(exception.message),
+    302, NOT_FOUND,
+    303, PRECONDITION_FAILED,
+    306, () => new http.Conflict(),
+    () => {
+      console.error(exception)
 
-  if (exception.code === 303)
-    throw new http.PreconditionFailed()
+      return exception
+    })
+}
 
-  throw exception as unknown as Error
+function badRequest (code: number): boolean {
+  return (code >= 200 && code < 210) || code === 221
 }
+
+const NOT_FOUND = new http.NotFound()
+const PRECONDITION_FAILED = new http.PreconditionFailed()

package/source/io.ts

@@ -1,4 +1,4 @@
-import type { IncomingMessage, OutgoingMessage } from './HTTP'
+import type { Context, OutgoingMessage } from './HTTP'
 
-export type Input = IncomingMessage
+export type Input = Context
 export type Output = OutgoingMessage | null

package/source/root.ts

@@ -25,6 +25,11 @@ const PREDEFINED: syntax.Node = {
                 family: 'auth',
                 name: 'echo',
                 value: null
+              },
+              {
+                family: 'io',
+                name: 'output',
+                value: ['id', 'roles']
               }
             ]
           }

package/source/schemas.ts

@@ -9,5 +9,5 @@ const path = resolve(__dirname, '../schemas')
 const namespace = schemas.namespace(path)
 
 export const querystring: Schema<Query> = namespace.schema('querystring')
-export const annotaion: Schema<Annotation> = namespace.schema('annotation')
+export const annotation: Schema<Annotation> = namespace.schema('annotation')
 export const node: Schema<Node> = namespace.schema('node')

package/transpiled/Annotation.d.ts

@@ -1,7 +1,8 @@
 export interface Annotation {
-    host?: string;
+    authorities: Record<string, string>;
     class?: string;
     annotations?: Record<string, string>;
-    debug: boolean;
+    debug?: boolean;
+    trace?: boolean;
     '/'?: object;
 }

package/transpiled/Context.d.ts

@@ -1,5 +1,7 @@
-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;
+}
+export {};

package/transpiled/Directive.d.ts

@@ -1,31 +1,18 @@
-import type { IncomingMessage, OutgoingMessage } from './HTTP';
+import type { Context, OutgoingMessage } from './HTTP';
 import type { Remotes } from './Remotes';
 import type { Output } from './io';
 import type * as RTD from './RTD';
-export declare class Directives implements RTD.Directives<Directives> {
+export declare class Directives implements RTD.Directives {
     private readonly sets;
-    constructor(sets: DirectiveSet[]);
-    preflight(request: IncomingMessage, parameters: RTD.Parameter[]): Promise<Output>;
-    settle(request: IncomingMessage, response: OutgoingMessage): Promise<void>;
-    merge(directives: Directives): void;
+    constructor(sets: RTD.DirectiveSet[]);
+    preflight(context: Context, parameters: RTD.Parameter[]): Promise<Output>;
+    settle(context: Context, response: OutgoingMessage): Promise<void>;
 }
-export declare class DirectivesFactory implements RTD.DirectivesFactory<Directives> {
-    private readonly remtoes;
+export declare class DirectivesFactory implements RTD.DirectiveFactory {
+    private readonly remotes;
     private readonly families;
     private readonly mandatory;
-    constructor(families: Family[], remotes: Remotes);
+    constructor(families: RTD.DirectiveFamily[], remotes: Remotes);
     create(declarations: RTD.syntax.Directive[]): Directives;
 }
 export declare const shortcuts: RTD.syntax.Shortcuts;
-export interface Family<TDirective = any, TExtension = any> {
-    readonly name: string;
-    readonly mandatory: boolean;
-    create: (name: string, value: any, remotes: Remotes) => TDirective;
-    preflight?: (directives: TDirective[], request: IncomingMessage & TExtension, parameters: RTD.Parameter[]) => Output | Promise<Output>;
-    settle?: (directives: TDirective[], request: IncomingMessage & TExtension, response: OutgoingMessage) => void | Promise<void>;
-}
-interface DirectiveSet {
-    family: Family;
-    directives: any[];
-}
-export {};