@toa.io/extensions.exposition 1.0.0-alpha.14 → 1.0.0-alpha.142

package/source/directives/dev/Sleep.ts

@@ -0,0 +1,40 @@
+import assert from 'node:assert'
+import { setTimeout } from 'node:timers/promises'
+import { console } from 'openspan'
+import { cors } from '../cors'
+import { BadRequest } from '../../HTTP'
+import type { Directive } from './types'
+import type { Input, Output } from '../../io'
+
+export class Sleep implements Directive {
+  private static warned = false
+  private readonly maximum: number
+
+  public constructor (value: number) {
+    assert.ok(Number.isInteger(value), '`dev:sleep` directive value must be an integer')
+
+    if (!Sleep.warned) {
+      console.warn(`Sleep directive is enabled (maximum: ${value}ms)`)
+      Sleep.warned = true
+    }
+
+    cors.allow('sleep')
+    this.maximum = value
+  }
+
+  public async apply (input: Input): Promise<Output> {
+    const value = input.request.headers.sleep as string | undefined
+
+    if (value === undefined)
+      return null
+
+    const duration = Number.parseInt(value)
+
+    if (Number.isNaN(duration) || duration < 0 || duration > this.maximum)
+      throw new BadRequest('Invalid sleep duration')
+
+    await setTimeout(duration)
+
+    return null
+  }
+}

package/source/directives/dev/types.ts

@@ -1,5 +1,5 @@
 import type { Input, Output } from '../../io'
 
 export interface Directive {
-  apply: (input: Input) => Output
+  apply: (input: Input) => Promise<Output> | Output
 }

package/source/directives/flow/Compose.ts

@@ -0,0 +1,92 @@
+import { once } from 'node:events'
+import * as assert from 'node:assert'
+import { Readable } from 'node:stream'
+import { console } from 'openspan'
+import type { Directive } from './types'
+import type { Input as Context } from '../../io'
+import type { OutgoingMessage } from '../../HTTP'
+
+export class Compose implements Directive {
+  private readonly expressions: Expression[]
+
+  public constructor (composition: any) {
+    this.expressions = build(composition)
+  }
+
+  public attach (context: Context): void {
+    context.pipelines.response.push(async (message: OutgoingMessage) => {
+      if (!(message.body instanceof Readable)) {
+        console.warn('Response body is not a stream, skipping composition')
+
+        return
+      }
+
+      assert.ok(message.body instanceof Readable, 'Response body is not a stream')
+
+      // @ts-expect-error -- objectMode is not defined in the type definition
+      assert.ok(message.body._readableState.objectMode, 'Response stream is not in object mode')
+
+      const $ = await this.compose(message.body)
+
+      message.body = this.execute($)
+    })
+  }
+
+  private async compose (stream: Readable): Promise<unknown[]> {
+    const $: unknown[] = []
+
+    stream.on('data', (data) => $.push(data))
+
+    await once(stream, 'end')
+
+    return $
+  }
+
+  private execute ($: unknown[]): unknown {
+    let exception: Error | undefined
+
+    for (const expression of this.expressions)
+      try {
+        return expression($)
+      } catch (e: unknown) {
+        exception = e as Error
+        console.debug('Chunks composition failed', { cause: exception.message })
+      }
+
+    throw exception!
+  }
+}
+
+function build (composition: any): Expression[] {
+  return Array.isArray(composition)
+    ? composition.map((variant) => compile(variant as object | string))
+    : [compile(composition as object | string)]
+}
+
+function compile (composition: object | string): Expression {
+  const text = typeof composition === 'string'
+    ? `return ${composition}`
+    : `return ${json(composition)}`
+
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval,no-new-func
+  return new Function('$', text) as Expression
+}
+
+function json (node: object | string): string {
+  if (typeof node === 'string')
+    if (node.startsWith('\\'))
+      return `"${node}"`
+    else
+      return node
+
+  if (Array.isArray(node))
+    return `[${node.map((v) => json(v as object | string)).join(',')}]`
+
+  if (node.constructor !== Object)
+    return JSON.stringify(node)
+
+  return '{' + Object.entries(node)
+    .map(([key, value]) => `"${key}": ${json(value as object | string)}`).join(',') + '}'
+}
+
+type Expression = ($: unknown[]) => unknown

package/source/directives/flow/Fetch.ts

@@ -0,0 +1,86 @@
+import { Readable } from 'node:stream'
+import assert from 'node:assert'
+import { match } from 'matchacho'
+import { NotFound } from '../../HTTP'
+import type { Directive } from './types'
+import type { ReadableStream } from 'node:stream/web'
+import type { Remotes } from '../../Remotes'
+import type { Maybe } from '@toa.io/types'
+import type { Component } from '@toa.io/core'
+import type { Output } from '../../io'
+import type { Input } from '../octets/types'
+import type { Parameter } from '../../RTD'
+
+export class Fetch implements Directive {
+  private readonly connecting: Promise<Component>
+  private remote: Component | null = null
+  private readonly operation: string
+
+  public constructor (endpoint: string, discovery: Remotes) {
+    assert.equal(typeof endpoint, 'string', '`flow:fetch` must be a string')
+
+    const [operation, name, namespace = 'default'] = endpoint.split('.').reverse()
+
+    this.operation = operation
+    this.connecting = discovery.discover(namespace, name)
+  }
+
+  public async apply (input: Input, parameters: Parameter[]): Promise<Output> {
+    if ('if-none-match' in input.request.headers)
+      return { status: 304 }
+
+    this.remote ??= await this.connecting
+
+    const request = await this.remote.invoke<Maybe<Request | string>>(this.operation, {
+      input: {
+        authority: input.authority,
+        path: input.request.url,
+        parameters: Object.fromEntries(parameters.map(({ name, value }) => [name, value]))
+      }
+    })
+
+    if (request instanceof Error)
+      throw new NotFound(request)
+
+    const { url, options } = match<Request>(request,
+      String, { url: request },
+      (request: Request): Request => ({
+        url: request.url,
+        options: {
+          method: request.options?.method ?? 'GET',
+          body: request.options?.body,
+          headers: request.options?.headers
+        }
+      }))
+
+    const response = await fetch(url, options)
+
+    if (!response.ok)
+      throw new NotFound()
+
+    const headers = new Headers()
+
+    for (const header of ['content-type', 'content-length', 'etag']) {
+      const value = response.headers.get(header)
+
+      if (value !== null)
+        headers.set(header, value)
+    }
+
+    return {
+      headers,
+      body: response.body === null ? null : Readable.fromWeb(response.body as ReadableStream)
+    }
+  }
+}
+
+interface Request {
+  url: string
+  options?: RequestOptions
+}
+
+interface RequestOptions {
+  method?: string
+  body?: string
+  headers?: Record<string, string>
+}

package/source/directives/flow/Flow.ts

@@ -0,0 +1,42 @@
+import { Fetch } from './Fetch'
+import { Compose } from './Compose'
+import type { Directive } from './types'
+import type { Input, Output } from '../../io'
+import type { DirectiveFamily, Parameter } from '../../RTD'
+import type { Remotes } from '../../Remotes'
+
+export class Flow implements DirectiveFamily<Directive> {
+  public readonly name: string = 'flow'
+  public readonly mandatory: boolean = false
+
+  public create (name: string, value: unknown, remotes: Remotes): Directive {
+    const Class = constructors[name]
+
+    if (Class === undefined)
+      throw new Error(`Directive '${this.name}:${name}' is not implemented`)
+
+    return new Class(value, remotes)
+  }
+
+  public async preflight (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
+    for (const directive of directives) {
+      if (directive.attach !== undefined)
+        directive.attach(input)
+
+      if (directive.apply === undefined)
+        continue
+
+      const output = await directive.apply(input, parameters)
+
+      if (output !== null)
+        return output
+    }
+
+    return null
+  }
+}
+
+const constructors: Record<string, new (value: any, discovery: Remotes) => Directive> = {
+  fetch: Fetch,
+  compose: Compose
+}

package/source/directives/flow/index.ts

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

package/source/directives/flow/types.ts

@@ -0,0 +1,7 @@
+import type { Input as Context, Input, Output } from '../../io'
+import type { Parameter } from '../../RTD'
+
+export interface Directive {
+  apply?: (input: Input, parameters: Parameter[]) => Promise<Output>
+  attach?: (context: Context) => void
+}

package/source/directives/index.ts

@@ -4,9 +4,11 @@ import { cors } from './cors'
 import { dev } from './dev'
 import { octets } from './octets'
 import { io } from './io'
-import { vary } from './vary'
+import { map } from './map'
+import { req } from './require'
+import { flow } from './flow'
 import type { DirectiveFamily } from '../RTD'
 import type { Interceptor } from '../Interception'
 
-export const families: DirectiveFamily[] = [authorization, io, cache, vary, octets, dev]
+export const families: DirectiveFamily[] = [authorization, io, cache, map, req, flow, octets, dev]
 export const interceptors: Interceptor[] = [cors]

package/source/directives/io/IO.ts

@@ -10,7 +10,7 @@ export class IO implements DirectiveFamily<Directive> {
 
   public create (name: string, value: unknown): Directive {
     if (!(name in constructors))
-      throw new Error(`Directive 'io:${name}' is not implemented.`)
+      throw new Error(`Directive 'io:${name}' is not implemented`)
 
     const Directive = constructors[name]
 

package/source/directives/io/Input.ts

@@ -12,24 +12,27 @@ export class Input implements Directive {
   }
 
   public static validate (permissions: unknown): asserts permissions is Permissions {
-    schemas.input.validate(permissions, 'Incorrect \'io:input\' format')
+    schemas.input.validate<Permissions>(permissions, 'Incorrect \'io:input\' format')
   }
 
   public attach (context: Context): void {
     context.pipelines.body.push((body) => this.check(body))
   }
 
-  private check (body: unknown): unknown {
+  private check (body: unknown): Message | Message[] | undefined {
+    if (body === undefined)
+      return body
+
     try {
-      schemas.message.validate(body)
+      schemas.message.validate<Message | Message[]>(body)
     } catch {
-      throw new BadRequest('Invalid request body.')
+      throw new BadRequest('Invalid request body')
     }
 
     const property = this.violation(body)
 
     if (property !== undefined)
-      throw new BadRequest(`Unexpected input: ${property}.`)
+      throw new BadRequest(`Unexpected input: ${property}`)
 
     return body
   }

package/source/directives/io/Output.ts

@@ -1,4 +1,5 @@
 import { Stream } from 'node:stream'
+import { console } from 'openspan'
 import * as schemas from './schemas'
 import type { Message } from './Message'
 import type { Directive } from './Directive'
@@ -40,19 +41,19 @@ export class Output implements Directive {
 
       if (typeof message.body !== 'object' || this.permissions.length === 0) {
         if (this.omitted)
-          console.warn('Permissions for \'io:output\' are not specified properly ' +
-            `(${context.request.url}). Response omitted.`)
+          console.warn('Permissions for \'io:output\' are not specified properly, response omitted',
+            { path: context.url.pathname })
 
         delete message.body
 
         return
       }
 
-      schemas.message.validate(message.body,
+      schemas.message.validate<Message>(message.body,
         '\'io:output\' expects response to be an object or array of objects')
 
       if (Array.isArray(message.body))
-        message.body = message.body.map((entity) => this.fit(entity))
+        message.body = message.body.map((entity) => this.fit(entity as Message))
       else
         message.body = this.fit(message.body)
     }

package/source/directives/map/Authority.ts

@@ -0,0 +1,15 @@
+import assert from 'node:assert'
+import { Mapping } from './Mapping'
+import type { Input } from '../../io'
+
+export class Authority extends Mapping<string> {
+  public constructor (property: string) {
+    assert.ok(typeof property === 'string', '`map:authority` must be a string')
+
+    super(property)
+  }
+
+  public properties (context: Input): Record<string, string> {
+    return { [this.value]: context.authority }
+  }
+}

package/source/directives/map/Claims.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert'
+import { Mapping } from './Mapping'
+import type { Component } from '@toa.io/core'
+import type { Remotes } from '../../Remotes'
+import type { Input } from '../../io'
+
+export class Claims extends Mapping<Record<string, string>> {
+  private readonly discovery!: Promise<Component>
+  private federation: Component | null = null
+
+  public constructor (map: Record<string, string>, remotes: Remotes) {
+    assert.ok(map.constructor === Object, '`map:claims` must be an object')
+
+    assert.ok(Object.values(map).every((value) => typeof value === 'string'),
+      '`map:claims ` must be an object with string values')
+
+    super(map, remotes)
+
+    this.discovery = remotes.discover('identity', 'federation')
+  }
+
+  public override async properties (context: Input): Promise<Record<string, string> | null> {
+    const authentication = context.request.headers.authorization
+
+    if (authentication === undefined)
+      return null
+
+    const claims = await this.claims(authentication)
+
+    if (claims === null)
+      return null
+
+    return Object.entries(this.value).reduce((properties: Record<string, string>, [property, claim]) => {
+      const value = claims[claim]
+
+      if (value !== undefined)
+        properties[property] = value
+
+      return properties
+    }, {})
+  }
+
+  private async claims (authentication: string): Promise<Record<string, string> | null> {
+    const [scheme, credentials] = authentication.split(' ')
+
+    if (scheme !== 'Bearer' || credentials === undefined)
+      return null
+
+    this.federation ??= await this.discovery
+
+    const claims = await this.federation.invoke<Record<string, string> | Error>('decode', { input: credentials })
+
+    if (claims instanceof Error)
+      return null
+
+    return claims
+  }
+}

package/source/directives/map/Directive.ts

@@ -0,0 +1,4 @@
+import type { Mapping } from './Mapping'
+import type { Property } from './Properties'
+
+export type Directive = Mapping | Property

package/source/directives/map/Headers.ts

@@ -0,0 +1,38 @@
+import assert from 'node:assert'
+import { cors } from '../cors'
+import { Mapping } from './Mapping'
+import type { Input } from '../../io'
+
+export class Headers extends Mapping<Record<string, string>> {
+  private readonly headers: string[]
+
+  public constructor (map: Record<string, string>) {
+    assert.ok(map.constructor === Object, '`map:headers` must be an object')
+
+    assert.ok(Object.values(map).every((value) => typeof value === 'string'),
+      '`map:headers` must be an object with string values')
+
+    super(map)
+
+    this.headers = Object.values(map).filter((header) => header !== 'host')
+    this.headers.forEach((header) => cors.allow(header))
+  }
+
+  public properties (context: Input): Record<string, string> {
+    context.pipelines.response.push((response) => {
+      response.headers ??= new global.Headers()
+
+      for (const header of this.headers)
+        response.headers.append('vary', header)
+    })
+
+    return Object.entries(this.value).reduce((properties: Record<string, string>, [property, header]) => {
+      const value = context.request.headers[header]
+
+      if (value !== undefined)
+        properties[property] = Array.isArray(value) ? value.join(', ') : value
+
+      return properties
+    }, {})
+  }
+}

package/source/directives/map/Language.ts

@@ -0,0 +1,42 @@
+import assert from 'node:assert'
+import Negotiator from 'negotiator'
+import { cors } from '../cors'
+import { Mapping } from './Mapping'
+import { Languages } from './Languages'
+import type { Input } from '../../io'
+import type { Parameter } from '../../RTD'
+import type { Directive } from './Directive'
+
+export class Language extends Mapping<string> {
+  private languages: string[] | null = null
+
+  public constructor (property: string) {
+    assert.ok(typeof property === 'string', '`map:language` must be a string')
+
+    cors.allow('accept-language')
+    super(property)
+  }
+
+  public properties (context: Input, parameters: Parameter[], directives: Directive[]): Record<string, string> {
+    this.languages ??= this.resolve(directives)
+
+    const negotiator = new Negotiator(context.request)
+    const language = negotiator.language(this.languages) ?? this.languages[0]
+
+    context.pipelines.response.push((response) => {
+      response.headers ??= new Headers()
+      response.headers.set('content-language', language)
+      response.headers.append('vary', 'accept-language')
+    })
+
+    return { [this.value]: language }
+  }
+
+  private resolve (directives: Directive[]): string[] {
+    for (const directive of directives)
+      if (directive instanceof Languages)
+        return directive.value
+
+    throw new Error('Supported languages are not defined, add `map:languages` directive')
+  }
+}

package/source/directives/map/Languages.ts

@@ -0,0 +1,11 @@
+import assert from 'node:assert'
+import { Property } from './Properties'
+
+export class Languages extends Property<'languages'> {
+  public constructor (value: string[]) {
+    assert.ok(Array.isArray(value) && value.length > 0, '`map:languages` must be a non-empty array of strings')
+    assert.ok(value.every((language) => typeof language === 'string'), '`map:languages` must be an array of strings')
+
+    super('languages', value)
+  }
+}

package/source/directives/map/Map.ts

@@ -0,0 +1,61 @@
+import { match } from 'matchacho'
+import { properties, Property } from './Properties'
+import { Mapping } from './Mapping'
+import { Headers } from './Headers'
+import { Languages } from './Languages'
+import { Language } from './Language'
+import { Segments } from './Segments'
+import { Authority } from './Authority'
+import { Claims } from './Claims'
+import type { Directive } from './Directive'
+import type { Properties } from './Properties'
+import type { DirectiveFamily, Parameter } from '../../RTD'
+import type { Input, Output } from '../../io'
+import type { Remotes } from '../../Remotes'
+
+export class Map implements DirectiveFamily {
+  public readonly name = 'map'
+  public readonly mandatory = false
+
+  private remotes!: Remotes
+
+  public create (name: string, value: unknown, remotes: Remotes): Property | Mapping {
+    this.remotes = remotes
+
+    return match(name,
+      () => properties.has(name), (name: PN) => new Property(name, value as PV),
+      () => name in mappings, (name: keyof typeof mappings) => new mappings[name](value, remotes),
+      () => {
+        throw new Error(`Directive 'map:${name}' is not implemented`)
+      })
+  }
+
+  public async preflight (directives: Directive[], context: Input, parameters: Parameter[]): Promise<Output> {
+    const properties = {}
+
+    for (const directive of directives)
+      if (directive instanceof Mapping)
+        Object.assign(properties, await directive.properties(context, parameters, directives))
+
+    context.pipelines.body.push((body: unknown) => {
+      if (body === undefined || body === null || typeof body !== 'object')
+        return properties
+      else
+        return Object.assign(body, properties)
+    })
+
+    return null
+  }
+}
+
+type PN = keyof Properties
+type PV = Properties[PN]
+
+const mappings: Record<string, new (value: any, remotes: Remotes) => Directive> = {
+  authority: Authority,
+  headers: Headers,
+  languages: Languages,
+  language: Language,
+  segments: Segments,
+  claims: Claims
+}

package/source/directives/map/Mapping.ts

@@ -0,0 +1,19 @@
+import type { Remotes } from '../../Remotes'
+import type { Directive } from './Directive'
+import type { Input } from '../../io'
+import type { Parameter } from '../../RTD'
+
+export abstract class Mapping<T = unknown> {
+  protected value: T
+  protected remotes?: Remotes
+
+  protected constructor (value: T, remotes?: Remotes) {
+    this.value = value
+    this.remotes = remotes
+  }
+
+  public abstract properties (context: Input, parameters: Parameter[], directives: Directive[]): Output
+}
+
+type Properties = Record<string, unknown> | null
+type Output = Properties | Promise<Properties>

package/source/directives/{vary → map}/Properties.ts

@@ -1,5 +1,5 @@
 export interface Properties {
-  languages?: string[]
+  languages: string[]
 }
 
 export class Property<K extends keyof Properties = keyof Properties> {
@@ -12,6 +12,4 @@ export class Property<K extends keyof Properties = keyof Properties> {
   }
 }
 
-export const properties: Properties = {
-  languages: []
-}
+export const properties = new Set('languages')

package/source/directives/map/Segments.ts

@@ -0,0 +1,33 @@
+import assert from 'node:assert'
+import { Mapping } from './Mapping'
+import type { Parameter } from '../../RTD'
+
+export class Segments extends Mapping<Record<string, string>> {
+  public constructor (map: Record<string, string>) {
+    assert.ok(map.constructor === Object, '`map:segments` must be an object')
+
+    assert.ok(Object.values(map).every((value) => typeof value === 'string'),
+      '`map:segments ` must be an object with string values')
+
+    super(map)
+  }
+
+  public override properties (_: unknown, parameters: Parameter[]): Record<string, string> {
+    return Object.entries(this.value).reduce((properties: Record<string, string>, [property, parameter]) => {
+      const cut = parameter[0] === '~'
+
+      if (cut) parameter = parameter.slice(1)
+
+      const index = parameters.findIndex(({ name }) => name === parameter)
+
+      assert.ok(index > -1, `Route parameter '${parameter}' is missing`)
+
+      properties[property] = parameters[index].value
+
+      if (cut)
+        parameters.splice(index, 1)
+
+      return properties
+    }, {})
+  }
+}