@toa.io/extensions.exposition 1.0.0-alpha.19 → 1.0.0-alpha.190

package/source/directives/io/lib/throttle/Quota.ts

@@ -0,0 +1,22 @@
+export class Quota {
+  private readonly limit: number = 0
+  private used: number = 0
+
+  public constructor (limit: number) {
+    this.limit = limit
+  }
+
+  public get idle (): boolean {
+    return this.used === 0
+  }
+
+  public use (count = 1): boolean {
+    this.used += count
+
+    return this.used < this.limit
+  }
+
+  public reset (): void {
+    this.used = 0
+  }
+}

package/source/directives/io/lib/throttle/Quotas.test.ts

@@ -0,0 +1,136 @@
+import { setTimeout } from 'node:timers/promises'
+import { Quotas } from './Quotas'
+import type { Configuration } from './Configuration'
+import type { Input as Context, Output } from '../../../../io'
+
+let quotas: Quotas
+let configuration: Configuration
+let context: Context
+let output: Output
+
+beforeEach(() => {
+  output = { status: 200 }
+})
+
+describe('common', () => {
+  beforeEach(() => {
+    context = createContext()
+    configuration = createConfiguration()
+    quotas = Quotas.create(configuration)
+  })
+
+  it('should be ok', () => {
+    quotas.ok(context)
+    quotas.use(context, output)
+  })
+
+  it('should throttle', () => {
+    expect(quotas.ok(context)).toBe(true)
+
+    quotas.use(context, output)
+    quotas.use(context, output)
+
+    expect(quotas.ok(context)).toBe(false)
+  })
+
+  it('should unblock after cooldown', async () => {
+    quotas.use(context, output)
+    quotas.use(context, output)
+
+    expect(quotas.ok(context)).toBe(false)
+
+    await timeout(configuration.cooldown)
+
+    expect(quotas.ok(context)).toBe(true)
+  })
+
+  it('should reset after interval', async () => {
+    quotas.use(context, output)
+
+    // pseudo-synchronous intervals start somewhere between 0 and interval
+    await timeout(configuration.interval * 2)
+
+    quotas.use(context, output)
+
+    expect(quotas.ok(context)).toBe(true)
+  })
+})
+
+describe('path', () => {
+  beforeEach(() => {
+    configuration = createConfiguration()
+    quotas = Quotas.create(configuration)
+  })
+
+  it('should have separate quotas', () => {
+    const one = createContext({ url: new URL('http://localhost/one/') })
+    const two = createContext({ url: new URL('http://localhost/two/') })
+
+    quotas.use(one, output)
+    quotas.use(one, output)
+
+    expect(quotas.ok(one)).toBe(false)
+    expect(quotas.ok(two)).toBe(true)
+
+    quotas.use(two, output)
+    quotas.use(two, output)
+
+    expect(quotas.ok(two)).toBe(false)
+  })
+})
+
+describe('ip', () => {
+  beforeEach(() => {
+    configuration = createConfiguration({ key: [{ method: 'ip' }] })
+    quotas = Quotas.create(configuration)
+  })
+
+  it('should have separate quotas', () => {
+    const one = createContext({ request: { headers: { 'x-forwarded-for': '1.1.1.1' } } })
+    const two = createContext({ request: { headers: { 'x-forwarded-for': '2.2.2.2' } } })
+
+    quotas.use(one, output)
+    quotas.use(one, output)
+
+    expect(quotas.ok(one)).toBe(false)
+    expect(quotas.ok(two)).toBe(true)
+
+    quotas.use(two, output)
+    quotas.use(two, output)
+
+    expect(quotas.ok(two)).toBe(false)
+  })
+})
+
+describe('status', () => {
+  beforeEach(() => {
+    context = createContext()
+    configuration = createConfiguration({ condition: [{ method: 'status', options: 404 }] })
+    quotas = Quotas.create(configuration)
+  })
+
+  it('should not throttle on 200', () => {
+    quotas.use(context, output)
+
+    expect(quotas.ok(context)).toBe(true)
+  })
+
+  it('should throttle on 404', () => {
+    quotas.use(context, { status: 404 })
+    quotas.use(context, { status: 404 })
+
+    expect(quotas.ok(context)).toBe(false)
+  })
+})
+
+function createConfiguration (properties?: Partial<Configuration>): Configuration {
+  return Object.assign({ key: [{ method: 'path' }], requests: 2, interval: 10, cooldown: 10 }, properties)
+}
+
+function createContext (properties?: any): Context {
+  return Object.assign({ url: new URL('http://localhost/') }, properties) as unknown as Context
+}
+
+async function timeout (ms: number): Promise<void> {
+  await setTimeout(ms * 1.2)
+}

package/source/directives/io/lib/throttle/Quotas.ts

@@ -0,0 +1,83 @@
+import { console } from 'openspan'
+import { Keys } from './Keys'
+import { Quota } from './Quota'
+import { Interval } from './Interval'
+import type { Configuration } from './Configuration'
+import type { Input as Context, Output } from '../../../../io'
+
+export class Quotas {
+  private readonly requests: number
+  private readonly cooldown: number
+  private readonly interval: Interval
+  private readonly keys: Keys
+  private readonly quotas: Record<string, Quota | undefined> = {}
+  private readonly blocked: Record<string, boolean | undefined> = {}
+
+  public constructor (options: Options) {
+    this.requests = options.requests
+    this.cooldown = options.cooldown
+    this.interval = options.interval
+    this.keys = options.keys
+
+    this.interval.on('tick', this.reset)
+  }
+
+  public static create (configuration: Configuration): Quotas {
+    const requests = configuration.requests
+    const cooldown = configuration.cooldown
+    const keys = Keys.create(configuration.key, configuration.condition)
+    const interval = new Interval(configuration.interval)
+
+    return new this({ requests, cooldown, keys, interval })
+  }
+
+  public ok (context: Context): boolean {
+    const key = this.keys.get(context)
+
+    return this.blocked[key] !== true
+  }
+
+  public use (input: Context, output: Output): void {
+    const key = this.keys.match(input, output)
+
+    if (key === null)
+      return
+
+    this.quotas[key] ??= new Quota(this.requests)
+
+    const ok = this.quotas[key]!.use()
+
+    if (!ok)
+      this.block(key)
+  }
+
+  public dispose (): void {
+    this.interval.dispose()
+  }
+
+  private readonly reset = (): void => {
+    for (const key in this.quotas) {
+      const quota = this.quotas[key]!
+
+      if (quota.idle)
+        delete this.quotas[key]
+      else
+        quota.reset()
+    }
+  }
+
+  private block (key: string): void {
+    this.blocked[key] = true
+
+    setTimeout(() => delete this.blocked[key], this.cooldown)
+
+    console.info('Quota exceeded, key blocked', { key, cooldown: this.cooldown })
+  }
+}
+
+interface Options {
+  keys: Keys
+  requests: number
+  cooldown: number
+  interval: Interval
+}

package/source/directives/io/lib/throttle/components/Component.ts

@@ -0,0 +1,5 @@
+import type { Input as Context } from '../../../../../io'
+
+export interface Component {
+  get: (context: Context) => string
+}

package/source/directives/io/lib/throttle/components/IP.ts

@@ -0,0 +1,40 @@
+import type { Context } from '../../../../../HTTP'
+import type { Component } from './Component'
+
+export class IP implements Component {
+  public get (context: Context): string {
+    return this.xff(context) ?? context.request.socket.remoteAddress ?? ''
+  }
+
+  private xff (context: Context): string | undefined {
+    const xff = context.request.headers['x-forwarded-for']
+
+    if (xff === undefined || typeof xff === 'string')
+      return xff
+
+    let ip
+
+    for (const value of xff) {
+      ip = value.trim()
+
+      if (!local(ip))
+        return ip
+    }
+
+    return ip // last otherwise
+  }
+}
+
+function local (ip: string): boolean {
+  return (
+    ip === 'unknown' ||
+    ip === '' ||
+    ip === '127.0.0.1' ||
+    ip === '::1' ||
+    ip.startsWith('10.') ||
+    ip.startsWith('192.168.') ||
+    ip.match(/^172\.(1[6-9]|2[0-9]|3[0-1])\./) !== null ||
+    ip.startsWith('fd') ||
+    ip.startsWith('fe80:')
+  )
+}

package/source/directives/io/lib/throttle/components/Path.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../../../../HTTP'
+import type { Component } from './Component'
+
+export class Path implements Component {
+  public get (context: Context): string {
+    return context.url.pathname
+  }
+}

package/source/directives/io/lib/throttle/components/index.ts

@@ -0,0 +1,13 @@
+import { Path } from './Path'
+import { IP } from './IP'
+import type { KeyComponentMethod } from '../Configuration'
+import type { Component } from './Component'
+
+type Constructor<T> = new (options: unknown) => T
+
+export const Components: Record<KeyComponentMethod, Constructor<Component>> = {
+  ip: IP,
+  path: Path
+}
+
+export type { Component }

package/source/directives/io/lib/throttle/conditions/Condition.ts

@@ -0,0 +1,5 @@
+import type { Input, Output } from '../../../../../io'
+
+export interface Condition {
+  match: (input: Input, output: Output) => boolean
+}

package/source/directives/io/lib/throttle/conditions/Status.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert'
+import type { Input, Output } from '../../../../../io'
+import type { Condition } from './Condition'
+
+export class Status implements Condition {
+  private readonly status: number
+
+  public constructor (status: unknown) {
+    assert.ok(typeof status === 'number', 'Status must be a number')
+
+    this.status = status
+  }
+
+  public match (input: Input, output: Output): boolean {
+    return output?.status === this.status
+  }
+}

package/source/directives/io/lib/throttle/conditions/index.ts

@@ -0,0 +1,11 @@
+import { Status } from './Status'
+import type { KeyConditionMethod } from '../Configuration'
+import type { Condition } from './Condition'
+
+type Constructor<T> = new (options: unknown) => T
+
+export const Conditions: Record<KeyConditionMethod, Constructor<Condition>> = {
+  status: Status
+}
+
+export type { Condition }

package/source/directives/io/lib/throttle/index.ts

@@ -0,0 +1,2 @@
+export { Quotas } from './Quotas'
+export { parse, type Configuration, type Declaration } from './Configuration'

package/source/directives/io/schemas.test.ts

@@ -0,0 +1,9 @@
+import * as schemas from './schemas'
+
+describe('throttle', () => {
+  const rest = { requests: 1, interval: 1, cooldown: 1 }
+
+  it('should validate key', () => {
+    expect(() => schemas.throttle.validate({ key: 'ip', ...rest })).not.toThrow()
+  })
+})

package/source/directives/io/schemas.ts

@@ -2,6 +2,8 @@ import { resolve } from 'node:path'
 import schemas, { type Schema } from '@toa.io/schemas'
 import type { Permissions as InputPermissions } from './Input'
 import type { Permissions as OutputPermissions } from './Output'
+import type { Declaration as ThrottleDeclaration } from './lib/throttle'
+
 import type { Message } from './Message'
 
 const path = resolve(__dirname, '../../../schemas/io')
@@ -10,3 +12,4 @@ const namespace = schemas.namespace(path)
 export const message: Schema<Message | Message[]> = namespace.schema('message')
 export const input: Schema<InputPermissions> = namespace.schema('input')
 export const output: Schema<OutputPermissions> = namespace.schema('output')
+export const throttle: Schema<ThrottleDeclaration> = namespace.schema('throttle')

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')