@toa.io/extensions.exposition 1.0.0-alpha.292 → 1.0.0-alpha.293

package/source/directives/map/Headers.ts

@@ -1,60 +0,0 @@
-import assert from 'node:assert'
-import { cors } from '../cors/index.js'
-import { Mapping } from './Mapping.js'
-import { take } from '../../Introspection.js'
-import type { Input } from '../../io.js'
-import type { Introspection } from '../../Introspection.js'
-
-/**
- * Forbidden request header names: the browser sets them itself and a script cannot
- * list them in `Access-Control-Request-Headers`, so there is nothing to advertise
- * or vary on. The value is still read, it just never reaches CORS.
- */
-const FORBIDDEN = new Set(['host', 'origin'])
-
-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) => !FORBIDDEN.has(header))
-    this.headers.forEach((header) => cors.allow(header))
-  }
-
-  /**
-   * The property is filled from a request header, so it is not the body's to send. Which
-   * header, and that there is one at all, is not answered: what an application reads off a
-   * request is its own, and a caller has nowhere to put one anyway.
-   */
-  public override explain(introspection: Introspection): void {
-    for (const property of Object.keys(this.value)) take(introspection, property)
-  }
-
-  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

@@ -1,45 +0,0 @@
-import assert from 'node:assert'
-import Negotiator from 'negotiator'
-import { cors } from '../cors/index.js'
-import { Mapping } from './Mapping.js'
-import { Languages } from './Languages.js'
-import type { Input } from '../../io.js'
-import type { Parameter } from '../../RTD/index.js'
-import type { Directive } from './Directive.js'
-
-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

@@ -1,17 +0,0 @@
-import assert from 'node:assert'
-import { Property } from './Properties.js'
-
-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

@@ -1,85 +0,0 @@
-import { match } from 'matchacho'
-import { properties, Property } from './Properties.js'
-import { Mapping } from './Mapping.js'
-import { Headers } from './Headers.js'
-import { Languages } from './Languages.js'
-import { Language } from './Language.js'
-import { Segments } from './Segments.js'
-import { Authority } from './Authority.js'
-import { BufferMapping } from './Buffer.js'
-import { Claims } from './Claims.js'
-import type { Directive } from './Directive.js'
-import type { Properties } from './Properties.js'
-import type { DirectiveFamily, Parameter } from '../../RTD/index.js'
-import type { Input, Output } from '../../io.js'
-import type { Introspection } from '../../Introspection.js'
-import type { Remotes } from '../../Remotes.js'
-
-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 explain(
-    directives: Directive[],
-    _: Input,
-    introspection: Introspection
-  ): Introspection {
-    for (const directive of directives)
-      if (directive instanceof Mapping) directive.explain(introspection)
-
-    return introspection
-  }
-
-  public async precall(
-    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,
-  buffer: BufferMapping,
-  headers: Headers,
-  languages: Languages,
-  language: Language,
-  segments: Segments,
-  claims: Claims
-}

package/source/directives/map/Mapping.ts

@@ -1,45 +0,0 @@
-import { take } from '../../Introspection.js'
-import type { Remotes } from '../../Remotes.js'
-import type { Directive } from './Directive.js'
-import type { Input } from '../../io.js'
-import type { Parameter } from '../../RTD/index.js'
-import type { Introspection } from '../../Introspection.js'
-
-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
-
-  /**
-   * What this mapping does to what the method says about itself, which is the reverse of
-   * what it does to a request: a property the gateway fills is taken out of the input,
-   * because it is not the caller's to send.
-   *
-   * The default says nothing more than that. A claim, an authority and a language come
-   * from the request itself and there is nowhere for a caller to put one; a header and a
-   * segment are the caller's, and those say where.
-   */
-  public explain(introspection: Introspection): void {
-    for (const property of this.names()) take(introspection, property)
-  }
-
-  /** The input properties this mapping fills, however its value names them. */
-  protected names(): string[] {
-    return typeof this.value === 'string'
-      ? [this.value]
-      : Object.keys(this.value as object)
-  }
-}
-
-type Properties = Record<string, unknown> | null
-type Output = Properties | Promise<Properties>

package/source/directives/map/Properties.ts

@@ -1,15 +0,0 @@
-export interface Properties {
-  languages: string[]
-}
-
-export class Property<K extends keyof Properties = keyof Properties> {
-  public readonly name: K
-  public readonly value: Properties[K]
-
-  public constructor(name: K, value: Properties[K]) {
-    this.name = name
-    this.value = value
-  }
-}
-
-export const properties = new Set('languages')

package/source/directives/map/Segments.ts

@@ -1,52 +0,0 @@
-import assert from 'node:assert'
-import { Mapping } from './Mapping.js'
-import { take } from '../../Introspection.js'
-import type { Parameter } from '../../RTD/index.js'
-import type { Introspection, Schema } from '../../Introspection.js'
-
-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)
-  }
-
-  /** A segment is the caller's, so it moves to the route rather than out of sight. */
-  public override explain(introspection: Introspection): void {
-    for (const property of Object.keys(this.value)) {
-      const schema = take(introspection, property)
-
-      introspection.route ??= {}
-      introspection.route[property] = schema ?? ({ type: 'string' } as unknown as Schema)
-    }
-  }
-
-  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
-      },
-      {}
-    )
-  }
-}

package/source/directives/map/index.ts

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

package/source/directives/mcp/MCP.ts

@@ -1,33 +0,0 @@
-import assert from 'node:assert'
-import { Tool } from './Tool.js'
-import type { DirectiveFamily } from '../../RTD/index.js'
-import type { Context } from '../../HTTP/index.js'
-import type { Introspection } from '../../Introspection.js'
-
-/** The name the family is declared under, and what `MCP` asks a method for. */
-export const FAMILY = 'mcp'
-
-export class MCP implements DirectiveFamily<Tool> {
-  public readonly name = FAMILY
-  public readonly mandatory = false
-
-  /** Whether this method is published, which is what the nearest declaration says. */
-  public static published(directives: Tool[] | undefined): boolean {
-    return directives?.[0]?.published ?? false
-  }
-
-  /**
-   * Whether this method is published to a model, which is what the route declares. Whether
-   * one is served at all is the annotation's, and a route says nothing of that.
-   */
-  public explain(directives: Tool[], _: Context, introspection: Introspection): Introspection {
-    return MCP.published(directives) ? { ...introspection, mcp: true } : introspection
-  }
-
-  // eslint-disable-next-line max-params
-  public create(name: string, value: unknown, _: unknown, route: string): Tool {
-    assert.ok(name === 'tool', `Unknown directive: mcp:${name}`)
-
-    return new Tool(value, route)
-  }
-}

package/source/directives/mcp/Tool.test.ts

@@ -1,56 +0,0 @@
-import assert from 'node:assert'
-import { describe, it } from 'node:test'
-import { Tool } from './Tool.js'
-import { MCP } from './MCP.js'
-
-describe('mcp:tool', () => {
-  it('should publish a method', () => {
-    assert.strictEqual(new Tool(true, '/pots/hot').published, true)
-  })
-
-  it('should withdraw one, because a declaration is inherited', () => {
-    assert.strictEqual(new Tool(false, '/pots/hot').published, false)
-  })
-
-  it('should not accept what a tool is, which is `help:method`', () => {
-    assert.throws(() => new Tool('The pots that are hot.', '/pots'), /`help:method`/)
-    assert.throws(() => new Tool({ title: 'Hot pots' }, '/pots'), /`help:method`/)
-  })
-
-  it('should not accept a value that is not one', () => {
-    assert.throws(() => new Tool(undefined, '/pots'), /whether the method is published/)
-    assert.throws(() => new Tool(null, '/pots'), /whether the method is published/)
-  })
-
-  it('should refuse a route no name can spell', () => {
-    assert.throws(() => new Tool(true, '/pots/v1.0'), /no tool name can spell/)
-  })
-
-  it('should name the route it refuses', () => {
-    assert.throws(() => new Tool(true, '/pots/v1.0'), /'\/pots\/v1\.0'/)
-  })
-
-  it('should not ask a route it does not publish to be spellable', () => {
-    assert.strictEqual(new Tool(false, '/pots/v1.0').published, false)
-  })
-})
-
-describe('mcp:tool inheritance', () => {
-  const mcp = new MCP()
-
-  it('should take the nearest declaration', () => {
-    const nearest = new Tool(false, '/pots')
-    const further = new Tool(true, '/pots')
-
-    assert.strictEqual(MCP.published([nearest, further]), false)
-  })
-
-  it('should publish nothing where nothing is declared', () => {
-    assert.strictEqual(MCP.published(undefined), false)
-    assert.strictEqual(MCP.published([]), false)
-  })
-
-  it('should refuse a directive it does not know', () => {
-    assert.throws(() => mcp.create('tools', true, null, '/pots'), /Unknown directive/)
-  })
-})

package/source/directives/mcp/Tool.ts

@@ -1,32 +0,0 @@
-import assert from 'node:assert'
-import { refusal } from '../../RPC/names.js'
-import { segment } from '../../RTD/segment.js'
-
-/**
- * Whether one method is published to a model. Declaring it is what publishes it, and it
- * says nothing else — what a tool is, is [`help:method`](../help/Help.ts), which is what
- * describes the method to everything else as well.
- *
- * `false` withdraws one: the declaration is inherited, as every directive is, and a node
- * publishing what is under it is how a subtree is published at all.
- */
-export class Tool {
-  public readonly published: boolean
-
-  public constructor(value: unknown, route: string) {
-    assert.ok(
-      typeof value === 'boolean',
-      'Directive mcp:tool: the value is whether the method is published; what it is, is `help:method`'
-    )
-
-    // a tool is called by name, so a route that cannot be named cannot be one — said where
-    // the mistake is, rather than as a tool that is quietly never listed
-    if (value)
-      assert.ok(
-        refusal(segment(route)) === null,
-        `Directive mcp:tool: '${route}' holds a segment no tool name can spell`
-      )
-
-    this.published = value
-  }
-}

package/source/directives/mcp/index.ts

@@ -1,6 +0,0 @@
-import { MCP } from './MCP.js'
-
-export const mcp = new MCP()
-
-export { FAMILY, MCP } from './MCP.js'
-export type { Tool } from './Tool.js'

package/source/directives/oauth/Discovery.ts

@@ -1,66 +0,0 @@
-import { documents, type Documents } from './documents.js'
-import type * as http from '../../HTTP/index.js'
-import type { Input, Output } from '../../io.js'
-import type { Interceptor } from '../../Interception.js'
-
-/**
- * What a client reads before it can authenticate: where the authorization server is, and
- * what this resource expects. Both are fixed paths a specification names, both must be
- * answered to anyone, and both are a function of the annotation alone — nothing is read to
- * build them, so they are built once per authority and served as they are.
- *
- * An interceptor rather than a route because `auth` runs before any directive: a client
- * re-reading discovery while holding a stale token would have it verified, and then be
- * refused a document that has to be public.
- */
-export class Discovery implements Interceptor {
-  /**
-   * A map, because the key is the request's authority and an unconfigured host is passed
-   * through as itself: `Host: constructor` names something a plain object answers on its own.
-   */
-  private readonly authorities = new Map<string, Documents>()
-
-  public mount(options: http.Options): void {
-    this.authorities.clear()
-
-    if (options.oauth === undefined) return
-
-    /*
-     * `https` always: RFC 8414 has an issuer be one, and OAuth 2.1 has every endpoint of an
-     * authorization server be one — the loopback exception is a client's redirect URI, not
-     * a server's address. A gateway served without TLS has no authorization server a client
-     * may use, and naming it `http` would hide that behind documents none should accept.
-     *
-     * The host is the configured one, not the request's, which is the client's to write: a
-     * forged one would have these documents name someone else's token endpoint.
-     */
-    for (const [authority, host] of Object.entries(options.authorities))
-      this.authorities.set(authority, documents(`https://${host}`, options.oauth))
-  }
-
-  public reset(): void {
-    this.authorities.clear()
-  }
-
-  public intercept(input: Input): Output {
-    const known = this.authorities.get(input.authority)
-
-    if (known === undefined) return null
-
-    // every reply, not just a document's: the challenge is what points a client here
-    input.pipelines.response.push((response) => {
-      if (response.status !== UNAUTHORIZED) return
-
-      response.headers ??= new Headers()
-      response.headers.set('www-authenticate', known.challenge(input.url.pathname))
-    })
-
-    const body = known.read(input.url.pathname)
-
-    if (body === undefined) return null
-
-    return { body, headers: new Headers({ 'cache-control': 'public, max-age=3600' }) }
-  }
-}
-
-const UNAUTHORIZED = 401

package/source/directives/oauth/documents.ts

@@ -1,110 +0,0 @@
-import type { OAuth } from '@toa.io/definitions/extensions.exposition'
-
-/** The discovery documents of one authority, and the challenge that points at them. */
-export interface Documents {
-  /** The document a path names, or nothing when it names none. */
-  read: (pathname: string) => object | undefined
-
-  /** `WWW-Authenticate` for a request to this path, which names the resource it failed at. */
-  challenge: (pathname: string) => string
-}
-
-export function documents(issuer: string, oauth: OAuth): Documents {
-  const server = authorizationServer(issuer, oauth)
-  const resources = protectedResources(issuer, oauth)
-  const scope = oauth.scopes === undefined ? '' : `, scope="${oauth.scopes.join(' ')}"`
-
-  function read(pathname: string): object | undefined {
-    if (pathname === AUTHORIZATION_SERVER || pathname === OPENID_CONFIGURATION)
-      return server
-
-    if (pathname.startsWith(PROTECTED_RESOURCE))
-      return resources.get(pathname.slice(PROTECTED_RESOURCE.length))
-
-    return undefined
-  }
-
-  function challenge(pathname: string): string {
-    return `Bearer resource_metadata="${issuer}${PROTECTED_RESOURCE}${suffix(oauth, pathname)}"${scope}`
-  }
-
-  return { read, challenge }
-}
-
-/**
- * RFC 8414. `authorization_endpoint` is the application's own page and may be anywhere;
- * everything else this extension serves. Both flags are load-bearing for a client that
- * prefers Client ID Metadata Documents: without either it falls back to registration.
- */
-function authorizationServer(issuer: string, oauth: OAuth): object {
-  const metadata: Record<string, unknown> = {
-    issuer,
-    authorization_endpoint: oauth.authorize,
-    token_endpoint: `${issuer}${TOKEN}`,
-    response_types_supported: ['code'],
-    grant_types_supported: ['authorization_code'],
-    code_challenge_methods_supported: ['S256'],
-    token_endpoint_auth_methods_supported: ['none'],
-    client_id_metadata_document_supported: true,
-    authorization_response_iss_parameter_supported: true
-  }
-
-  if (oauth.registration === 'open')
-    metadata.registration_endpoint = `${issuer}${REGISTRATION}`
-
-  if (oauth.scopes !== undefined) metadata.scopes_supported = oauth.scopes
-
-  return metadata
-}
-
-/**
- * RFC 9728, keyed by the path the well-known segment is followed by: a client resolving
- * `https://host/mcp` reads `/.well-known/oauth-protected-resource/mcp`, and one that names
- * no path reads the document at the origin.
- */
-function protectedResources(issuer: string, oauth: OAuth): Map<string, object> {
-  const map = new Map<string, object>()
-
-  for (const path of oauth.resources ?? [])
-    map.set(canonical(path), resource(issuer, canonical(path), oauth))
-
-  map.set('', resource(issuer, '', oauth))
-
-  return map
-}
-
-function resource(issuer: string, path: string, oauth: OAuth): object {
-  const metadata: Record<string, unknown> = {
-    resource: issuer + path,
-    authorization_servers: [issuer],
-    bearer_methods_supported: ['header']
-  }
-
-  if (oauth.scopes !== undefined) metadata.scopes_supported = oauth.scopes
-
-  return metadata
-}
-
-/** The document a request to this path was refused against: the longest resource holding it. */
-function suffix(oauth: OAuth, pathname: string): string {
-  let longest = ''
-
-  for (const path of oauth.resources ?? [])
-    if (pathname.startsWith(path) && path.length > longest.length) longest = path
-
-  return canonical(longest)
-}
-
-/**
- * A resource is identified without its trailing slash — the form MCP asks for — while a
- * route is declared with one, so `/mcp/` identifies `…/mcp`.
- */
-function canonical(path: string): string {
-  return path.endsWith('/') ? path.slice(0, -1) : path
-}
-
-const AUTHORIZATION_SERVER = '/.well-known/oauth-authorization-server'
-const PROTECTED_RESOURCE = '/.well-known/oauth-protected-resource'
-const OPENID_CONFIGURATION = '/.well-known/openid-configuration'
-const TOKEN = '/identity/grants/'
-const REGISTRATION = '/identity/clients/'

package/source/directives/oauth/index.ts

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

package/source/directives/octets/Context.ts

@@ -1,23 +0,0 @@
-import assert from 'node:assert'
-import { Directive } from './Directive.js'
-import type { Output } from '../../io.js'
-
-export class Context extends Directive {
-  public readonly targeted = false
-  public readonly storage: string
-
-  public constructor(value: unknown) {
-    super()
-
-    assert.ok(
-      typeof value === 'string',
-      "Directive 'octets:context' must must be a string"
-    )
-
-    this.storage = value
-  }
-
-  public async apply(): Promise<Output> {
-    return null
-  }
-}