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

package/source/directives/auth/schemes.ts

@@ -1,9 +1,12 @@
-import { type Remote, type Scheme } from './types'
+import type { Remote, Scheme } from './types'
 
 export const PROVIDERS: Record<Scheme, Remote> = {
   basic: 'basic',
   token: 'tokens',
-  bearer: 'federation'
+  bearer: 'federation',
+  code: 'federation',
+  otp: 'otp'
 }
 
+export const INCEPTION: Remote[] = ['basic', 'federation']
 export const PRIMARY: Scheme = 'token'

package/source/directives/auth/split.ts

@@ -5,7 +5,7 @@ export function split (authorization: string): [Scheme, string] {
   const space = authorization.indexOf(' ')
 
   if (space === -1)
-    throw new http.Unauthorized('Malformed authorization header.')
+    throw new http.Unauthorized('Malformed authorization header')
 
   const Scheme = authorization.slice(0, space)
   const scheme = Scheme.toLowerCase() as Scheme

package/source/directives/auth/types.ts

@@ -5,21 +5,24 @@ import type * as http from '../../HTTP'
 import type * as io from '../../io'
 
 export interface Directive {
+  priority?: number
+
   authorize: (
     identity: Identity | null,
-    input: Input,
+    context: Context,
     parameters: Parameter[]
   ) => boolean | Promise<boolean>
 
-  reply?: (identity: Identity | null) => http.OutgoingMessage
+  reply?: (context: Context) => http.OutgoingMessage | null
 
-  settle?: (request: Input, response: http.OutgoingMessage) => Promise<void>
+  settle?: (context: Context, response: http.OutgoingMessage) => Promise<void>
 }
 
 export interface Identity {
   readonly id: string
-  scheme: string
   roles?: string[]
+  permissions?: Record<string, string[]>
+  scheme: string | null // null for transient identities
   refresh: boolean
 }
 
@@ -31,10 +34,12 @@ export interface Ban {
   banned: boolean
 }
 
-export type Input = io.Input & Extension
+export type Context = io.Input & Extension
 export type AuthenticationResult = Maybe<{ identity: Identity, refresh: boolean }>
 
-export type Scheme = 'basic' | 'token' | 'bearer'
-export type Remote = 'basic' | 'federation' | 'tokens' | 'roles' | 'bans'
+export type Scheme = 'basic' | 'token' | 'bearer' | 'code' | 'otp'
+export type Remote = 'basic' | 'federation' | 'tokens' | 'roles' | 'bans' | 'otp'
 export type Discovery = Record<Remote, Promise<Component>>
 export type Schemes = Record<Scheme, Component>
+
+export type Create = (name: string, value: any, ...args: any[]) => Directive

package/source/directives/cache/Cache.ts

@@ -1,19 +1,19 @@
 import { Control } from './Control'
 import { Exact } from './Exact'
-import type { Input, Output } from '../../io'
-import type { Directive } from './types'
+import type { Output } from '../../io'
+import type { AuthenticatedContext, Directive } from './types'
 import type { DirectiveFamily } from '../../RTD'
 import type * as http from '../../HTTP'
 
 export class Cache implements DirectiveFamily<Directive> {
   public readonly name: string = 'cache'
-  public readonly mandatory: boolean = false
+  public readonly mandatory: boolean = true
 
   public create (name: string, value: any): Directive {
     const Class = constructors[name]
 
     if (Class === undefined)
-      throw new Error(`Directive 'cache:${name}' is not implemented.`)
+      throw new Error(`Directive 'cache:${name}' is not implemented`)
 
     return new Class(value)
   }
@@ -22,10 +22,23 @@ export class Cache implements DirectiveFamily<Directive> {
     return null
   }
 
-  public async settle
-  (directives: Directive[], input: Input, response: http.OutgoingMessage): Promise<void> {
+  public async settle (directives: Directive[], context: AuthenticatedContext, response: http.OutgoingMessage): Promise<void> {
+    const method = context.request.method
+
+    if (method !== 'GET' && method !== 'HEAD')
+      return
+
+    const directive = directives[0]
+
     response.headers ??= new Headers()
-    directives[0]?.set(input, response.headers)
+
+    if (directive === undefined) {
+      if (context.identity !== null && !Control.disabled(response.headers)) {
+        response.headers.set('cache-control', 'private')
+        response.headers.append('vary', 'authorization')
+      }
+    } else
+      directive.set(context, response.headers)
   }
 }
 

package/source/directives/cache/Control.ts

@@ -3,25 +3,36 @@ import type { AuthenticatedContext, Directive } from './types'
 
 export class Control implements Directive {
   protected readonly value: string
-  private cache: string | null = null
+  private control: string | null = null
   private vary: boolean = false
 
   public constructor (value: string) {
     this.value = value
   }
 
+  public static disabled (headers: Headers): boolean {
+    const value = headers.get('cache-control')
+
+    if (value === null)
+      return false
+
+    const directives = mask(value)
+
+    return (directives & NO_STORE) === NO_STORE
+  }
+
   public set (context: AuthenticatedContext, headers: Headers): void {
     if (!['GET', 'HEAD', 'OPTIONS'].includes(context.request.method))
       return
 
-    this.cache ??= this.resolve(context)
+    this.control ??= this.resolve(context)
 
-    if (this.disabled(headers))
+    if (Control.disabled(headers))
       return
 
-    headers.append('cache-control', this.cache)
+    headers.set('cache-control', this.control)
 
-    if (this.vary !== null)
+    if (this.vary)
       headers.append('vary', 'authorization')
   }
 
@@ -45,17 +56,6 @@ export class Control implements Directive {
 
     return this.value
   }
-
-  private disabled (headers: Headers): boolean {
-    const value = headers.get('cache-control')
-
-    if (value === null)
-      return false
-
-    const directives = mask(value)
-
-    return (directives & NO_STORE) === NO_STORE
-  }
 }
 
 function mask (value: string): number {

package/source/directives/cors/CORS.ts

@@ -8,13 +8,12 @@ export class CORS implements Interceptor {
     '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-methods': 'GET, POST, PUT, PATCH, DELETE, LOCK, UNLOCK',
     'access-control-allow-credentials': 'true',
     'access-control-allow-headers': Array.from(this.requestHeaders).join(', '),
     'access-control-max-age': '3600',
@@ -25,17 +24,18 @@ export class CORS implements Interceptor {
   public intercept (input: Input): Output {
     const origin = input.request.headers.origin
 
-    if (origin === undefined)
-      return null
-
-    if (input.request.method === 'OPTIONS')
+    if (origin !== undefined && input.request.method === 'OPTIONS')
       return this.preflightResponse(origin)
 
     input.pipelines.response.push((output) => {
       output.headers ??= new Headers()
-      output.headers.set('access-control-allow-origin', origin)
-      output.headers.set('access-control-expose-headers',
-        'authorization, content-type, content-length, etag')
+
+      if (origin !== undefined) {
+        output.headers.set('access-control-allow-origin', origin)
+        output.headers.set('access-control-allow-credentials', 'true')
+        output.headers.set('access-control-expose-headers',
+          'authorization, content-type, content-length, date, etag, last-modified')
+      }
 
       const method = input.request.method
 

package/source/directives/dev/Development.ts

@@ -1,5 +1,7 @@
 import { Stub } from './Stub'
 import { Throw } from './Throw'
+import { Sleep } from './Sleep'
+import { Faulty } from './Faulty'
 import { type Directive } from './types'
 import type { Input, Output } from '../../io'
 import type { DirectiveFamily } from '../../RTD'
@@ -12,24 +14,29 @@ export class Development implements DirectiveFamily<Directive> {
     const Class = constructors[name]
 
     if (Class === undefined)
-      throw new Error(`Directive 'dev:${name}' is not implemented.`)
+      throw new Error(`Directive 'dev:${name}' is not implemented`)
 
     return new Class(value)
   }
 
-  public preflight (directives: Directive[], input: Input): Output {
+  public async preflight (directives: Directive[], input: Input): Promise<Output> {
+    let output = null
+
     for (const directive of directives) {
-      const output = directive.apply(input)
+      const out = await directive.apply(input)
 
-      if (output !== null)
-        return output
+      if (out !== null)
+        if (output !== null) throw new Error('`dev` directives ambiguous output')
+        else output = out
     }
 
-    return null
+    return output
   }
 }
 
 const constructors: Record<string, new (value: any) => Directive> = {
   stub: Stub,
-  throw: Throw
+  throw: Throw,
+  sleep: Sleep,
+  faulty: Faulty
 }

package/source/directives/dev/Faulty.ts

@@ -0,0 +1,26 @@
+import assert from 'node:assert'
+import { ServiceUnavailable } from '../../HTTP'
+import { cors } from '../cors'
+import type { Output } from '../../io'
+import type { Directive } from './types'
+
+export class Faulty implements Directive {
+  private static readonly warned = false
+  private readonly probability: number
+
+  public constructor (probability: number) {
+    assert.ok(typeof probability === 'number', '`dev:faulty` directive value must be a number')
+    assert.ok(probability > 0 && probability <= 1, '`dev:faulty` directive value must be in the range (0, 1]')
+
+    this.probability = probability
+
+    cors.allow('faulty')
+  }
+
+  public async apply (): Promise<Output> {
+    if (Math.random() > this.probability)
+      return null
+
+    throw new ServiceUnavailable()
+  }
+}

package/source/directives/dev/Sleep.ts

@@ -0,0 +1,55 @@
+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 })
+      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 [min, max] = this.parse(value)
+
+    if (min < 0 || max < 0 || min > max || max > this.maximum)
+      throw new BadRequest('Invalid sleep duration')
+
+    const duration = Math.floor(Math.random() * (max - min)) + min
+
+    await setTimeout(duration)
+
+    return null
+  }
+
+  private parse (value: string): [number, number] {
+    try {
+      const pair = JSON.parse(value) as [number, number]
+
+      if (!Array.isArray(pair) || pair.length !== 2)
+        throw new Error()
+
+      return pair
+    } catch (error) {
+      throw new BadRequest('Invalid sleep duration value')
+    }
+  }
+}

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,10 +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, req, octets, dev]
+export const families: DirectiveFamily[] = [authorization, io, cache, map, req, flow, octets, dev]
 export const interceptors: Interceptor[] = [cors]

package/source/directives/io/Directive.ts

@@ -1,7 +1,10 @@
-import type { Input } from '../../io'
+import type { Input as Context } from '../../io'
+import type * as http from '../../HTTP'
 
 export interface Directive {
-  attach: (context: Input) => void
+  preflight: (context: Context) => void
+  settle?: (context: Context, response: http.OutgoingMessage) => Promise<void> | void
+  dispose?: () => void
 }
 
 export interface Constructor {