@toa.io/extensions.exposition 1.0.0-alpha.28 → 1.0.0-alpha.283

package/source/Interception.ts

@@ -1,10 +1,18 @@
-import type { Input, Output } from './io'
+import type * as http from './HTTP/index.js'
+import type { Input, Output } from './io.js'
 
 export class Interception implements Interceptor {
   private readonly interceptors: Interceptor[]
 
-  public constructor (interceptors: Interceptor[]) {
+  public constructor (interceptors: Interceptor[], options: http.Options) {
     this.interceptors = interceptors
+
+    // interceptors are module singletons, so a second gateway in one process —
+    // which is how the features run — would otherwise inherit the first one's state
+    for (const interceptor of interceptors) {
+      interceptor.reset?.()
+      interceptor.mount?.(options)
+    }
   }
 
   public async intercept (input: Input): Promise<Output> {
@@ -21,4 +29,10 @@ export class Interception implements Interceptor {
 
 export interface Interceptor {
   intercept: (input: Input) => Output | Promise<Output>
+
+  /** Discards whatever the interceptor accumulated while serving. */
+  reset?: () => void
+
+  /** What the annotation says, for an interceptor that answers from it. */
+  mount?: (options: http.Options) => void
 }

package/source/Introspection.ts

@@ -0,0 +1,11 @@
+import type { Remote } from '@toa.io/core'
+
+export interface Introspection {
+  route?: Record<string, Schema>
+  query?: Record<string, Schema>
+  input?: Schema
+  output?: Schema
+  errors?: string[]
+}
+
+export type Schema = Awaited<ReturnType<Remote['explain']>>['input']

package/source/Mapping.ts

@@ -1,51 +1,85 @@
-import { type Parameter } from './RTD'
-import { Query } from './Query'
-import type * as http from './HTTP'
-import type * as syntax from './RTD/syntax'
+import { type Parameter } from './RTD/index.js'
+import { Query } from './Query.js'
+import type { Introspection, Schema } from './Introspection.js'
+import type { QueryString } from './Query.js'
+import type * as http from './HTTP/index.js'
+import type * as syntax from './RTD/syntax/index.js'
 import type * as core from '@toa.io/core'
 
 export abstract class Mapping {
-  public static create (query?: syntax.Query): Mapping {
-    if (query === undefined || query === null)
-      return new InputMapping()
+  protected readonly query: Query
+  public abstract readonly queryable: boolean
 
-    const q = new Query(query)
+  public constructor (query: Query) {
+    this.query = query
+  }
+
+  public static create (query?: syntax.Query | null): Mapping {
+    const q = new Query(query!)
 
-    return new QueryableMapping(q)
+    return queryable(query)
+      ? new QueryableMapping(q)
+      : new InputMapping(q)
   }
 
-  public abstract fit (input: any, qs: http.Query, parameters: Parameter[]): core.Request
+  public explain (introspection: Introspection): Record<string, Schema> | null {
+    return this.query.explain(introspection)
+  }
+
+  protected assign (input: any, qs: QueryString): void {
+    if (qs.parameters !== null) {
+      if (typeof input !== 'object' || input === null)
+        throw new Error('Input must be an object to embed query parameters')
+
+      Object.assign(input, qs.parameters)
+    }
+  }
+
+  public abstract fit (input: any, query: http.Query, parameters: Parameter[]): core.Request
 }
 
 class QueryableMapping extends Mapping {
-  private readonly query: Query
+  public override readonly queryable = true
 
-  public constructor (query: Query) {
-    super()
+  public fit (input: any, query: http.Query, parameters: Parameter[]): core.Request {
+    const request: core.Request = {}
+    const qs = this.query.fit(query, parameters)
 
-    this.query = query
-  }
+    if (input === undefined && qs.parameters !== null)
+      input = {}
 
-  public fit (input: any, qs: http.Query, parameters: Parameter[]): core.Request {
-    const query = this.query.fit(qs, parameters)
+    this.assign(input, qs)
 
-    return {
-      input,
-      query
-    }
+    if (input !== undefined)
+      request.input = input
+
+    if (qs.query !== null)
+      request.query = qs.query
+
+    return request
   }
 }
 
 class InputMapping extends Mapping {
-  public fit (input: any, _: unknown, parameters: Parameter[]): core.Request {
+  public override readonly queryable = false
+
+  public fit (input: any, query: http.Query, parameters: Parameter[]): core.Request {
     const request: core.Request = {}
+    const qs = this.query.fit(query, parameters)
 
-    if (input === undefined && parameters.length > 0)
+    if (input === undefined &&
+      (this.query.parameterized || parameters.length > 0 || qs.parameters !== null))
       input = {}
 
-    if (typeof input === 'object' && input !== null)
+    if (parameters.length > 0) {
+      if (typeof input !== 'object' || input === null)
+        throw new Error('Input must be an object to embed parameters')
+
       for (const parameter of parameters)
         input[parameter.name] = parameter.value
+    }
+
+    this.assign(input, qs)
 
     if (input !== undefined)
       request.input = input
@@ -53,3 +87,12 @@ class InputMapping extends Mapping {
     return request
   }
 }
+
+export function queryable (query?: syntax.Query | null): boolean {
+  if (query === undefined || query === null)
+    return false
+
+  const keys = Object.keys(query)
+
+  return !(keys.length === 1 && keys[0] === 'parameters')
+}

package/source/Query.test.ts

@@ -1,5 +1,8 @@
-import { Query } from './Query'
-import { type Parameter, type syntax } from './RTD'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Query } from './Query.js'
+import { type Parameter, type syntax } from './RTD/index.js'
 
 it('should combine request criteria', async () => {
   const query: syntax.Query = {
@@ -16,7 +19,21 @@ it('should combine request criteria', async () => {
   const instance = new Query(query)
   const result = instance.fit({ criteria: 'qux==4' }, parameters)
 
-  expect(result.criteria).toStrictEqual('(bar==2;baz==3);(foo==1);(qux==4)')
+  assert.deepStrictEqual(result.query!.criteria, '(bar=="2";baz=="3");(foo==1);(qux==4)')
+})
+
+it('should quote parameter values', async () => {
+  const query: syntax.Query = {
+    omit: { range: [0, 1] },
+    limit: { range: [0, 1] }
+  }
+
+  const parameters: Parameter[] = [{ name: 'user', value: 'me"),(user=="victim' }]
+
+  const instance = new Query(query)
+  const result = instance.fit({}, parameters)
+
+  assert.deepStrictEqual(result.query!.criteria, '(user=="me\\"),(user==\\"victim")')
 })
 
 it('should set id parameter as query.id', async () => {
@@ -32,6 +49,6 @@ it('should set id parameter as query.id', async () => {
   const instance = new Query(query)
   const result = instance.fit({}, parameters)
 
-  expect(result.criteria).toBeUndefined()
-  expect(result.id).toStrictEqual(id)
+  assert.strictEqual(result.query!.criteria, undefined)
+  assert.deepStrictEqual(result.query!.id, id)
 })

package/source/Query.ts

@@ -1,42 +1,125 @@
-import * as http from './HTTP'
-import { type Parameter } from './RTD'
-import * as schemas from './schemas'
-import type * as syntax from './RTD/syntax'
+import assert from 'node:assert'
+import { quote } from '@toa.io/generic'
+import * as http from './HTTP/index.js'
+import { type Parameter } from './RTD/index.js'
+import * as schemas from './schemas.js'
+import { queryable } from './Mapping.js'
+import type { Introspection, Schema } from './Introspection.js'
+import type * as syntax from './RTD/syntax/index.js'
 import type * as core from '@toa.io/core'
 
 export class Query {
+  public readonly parameterized: boolean
+
   private readonly query: syntax.Query
   private readonly closed: boolean = false
   private readonly prepend: ',' | ';' = ';'
+  private readonly queryable: boolean
+  private readonly searchable: boolean
 
   public constructor (query: syntax.Query) {
-    if (query.criteria !== undefined) {
-      if (query.criteria.endsWith(';'))
-        query.criteria = query.criteria.slice(0, -1)
-      else
-        this.closed = true
+    this.parameterized = query?.parameters !== undefined
+    this.queryable = queryable(query)
+    this.searchable = query?.search === true
+
+    if (this.queryable) {
+      query.omit ??= { value: 0, range: [0, 1000] }
+      query.limit ??= { value: 10, range: [1, 100] }
+
+      if (query.criteria !== undefined) {
+        // eslint-disable-next-line max-depth
+        if (query.criteria.endsWith(';'))
+          query.criteria = query.criteria.slice(0, -1)
+        else
+          this.closed = true
+
+        // eslint-disable-next-line max-depth
+        if (query.criteria.startsWith(',') || query.criteria.startsWith(';')) {
+          this.prepend = query.criteria[0] as ',' | ';'
+
+          query.criteria = query.criteria.slice(1)
+        }
+      }
+    }
+
+    this.query = query
+  }
+
+  public fit (query: http.Query, parameters: Parameter[]): QueryString {
+    const qs = this.split(query)
 
-      if (query.criteria.startsWith(',') || query.criteria.startsWith(';')) {
-        this.prepend = query.criteria[0] as ',' | ';'
+    if (qs.query !== null) {
+      const error = schemas.querystring.fit(qs.query)
+
+      if (error !== null)
+        throw new http.BadRequest('Query ' + error.message)
+
+      this.fitCriteria(qs.query, parameters)
+      this.fitRanges(qs.query)
+      this.fitSort(qs.query)
+
+      if (this.query.deleted !== undefined)
+        (qs.query as core.Query).deleted = this.query.deleted
+    }
+
+    return {
+      query: qs.query as core.Query,
+      parameters: qs.parameters
+    }
+  }
 
-        query.criteria = query.criteria.slice(1)
+  public explain (introspection: Introspection): Record<string, Schema> | null {
+    if (this.query?.parameters === undefined || introspection.input?.type !== 'object')
+      return null
+
+    let query: Record<string, Schema> | null = null
+
+    for (const parameter of this.query.parameters) {
+      const schema = introspection.input.properties[parameter]
+
+      if (schema !== undefined) {
+        query ??= {}
+        query[parameter] = schema
       }
+
+      delete introspection.input.properties[parameter]
     }
 
-    this.query = query
+    return query
   }
 
-  public fit (query: http.Query, parameters: Parameter[]): core.Query {
-    const error = schemas.querystring.fit(query)
+  private split (query: http.Query): {
+    query: http.Query | null
+    parameters: Record<string, string> | null
+  } {
+    let parameters: Record<string, string> | null = null
+
+    if (this.query?.parameters !== undefined)
+      for (const key in query)
+        // eslint-disable-next-line max-depth
+        if (this.query.parameters.includes(key)) {
+          parameters ??= {}
+          parameters[key] = query[key] as string
+
+          delete query[key]
+        }
 
-    if (error !== null)
-      throw new http.BadRequest('Query ' + error.message)
+    if (!this.queryable) {
+      const keys = Object.keys(query)
 
-    this.fitCriteria(query, parameters)
-    this.fitRanges(query)
-    this.fitSort(query)
+      if (keys.length > 0)
+        throw new http.BadRequest(`Query parameter '${keys[0]}' is not allowed`)
 
-    return query as core.Query
+      query = null!
+    }
+
+    if (query?.search !== undefined && !this.searchable)
+      throw new http.BadRequest('Query search is not allowed')
+
+    return {
+      query,
+      parameters
+    }
   }
 
   private fitCriteria (query: http.Query, parameters: Parameter[]): void {
@@ -50,8 +133,9 @@ export class Query {
     }
 
     if (parameters.length > 0) {
+      // a segment may carry `,` `;` `(` `)` `=`, which is criteria grammar when unquoted
       const criteria = parameters
-        .map(({ name, value }) => `${name}==${value}`)
+        .map(({ name, value }) => `${name}==${quote(value)}`)
         .join(';')
 
       groups.push({ criteria, operator: this.prepend })
@@ -77,6 +161,9 @@ export class Query {
   private fitRanges (qs: http.Query): void {
     const query = qs as core.Query
 
+    assert.ok(this.query.limit !== undefined, 'Query limit must be defined')
+    assert.ok(this.query.omit !== undefined, 'Query limit range must be defined')
+
     if (qs.limit !== undefined)
       query.limit = fit(qs.limit, this.query.limit.range, 'limit')
     else
@@ -114,3 +201,8 @@ interface CriteriaGroup {
   criteria: string
   operator: ',' | ';'
 }
+
+export interface QueryString {
+  query: core.Query | null
+  parameters: Record<string, string> | null
+}

package/source/RTD/Context.ts

@@ -1,6 +1,6 @@
-import { type DirectiveFactory } from './Directives'
-import { type EndpointsFactory } from './Endpoint'
-import type { Directive } from './syntax'
+import { type DirectiveFactory } from './Directives.js'
+import { type EndpointsFactory } from './Endpoint.js'
+import type { Directive } from './syntax/index.js'
 
 export interface Context<TExtension = any> {
   readonly protected: boolean
@@ -9,5 +9,8 @@ export interface Context<TExtension = any> {
     readonly factory: DirectiveFactory
     stack: Directive[]
   }
-  readonly extension?: TExtension
+
+  /** The route being built, accumulated on the way down and restored on the way up. */
+  path: string
+  readonly extension: TExtension
 }

package/source/RTD/Directives.ts

@@ -1,20 +1,28 @@
-import type { Parameter } from './Match'
-import type * as syntax from './syntax'
-import type { Context, OutgoingMessage } from '../HTTP'
-import type { Output } from '../io'
+import type { Parameter } from './Match.js'
+import type * as syntax from './syntax/index.js'
+import type { Context, OutgoingMessage, Options } from '../HTTP/index.js'
+import type { Output } from '../io.js'
+import type { extensions } from '@toa.io/core'
+
+type Host = extensions.Host
 
 export interface Directives {
   preflight: (context: Context, parameters: Parameter[]) => Promise<Output>
   settle: (context: Context, response: OutgoingMessage) => Promise<void>
+  dispose: () => void
 }
 
 export interface DirectiveFactory {
-  create: (directives: syntax.Directive[]) => Directives
+  create: (directives: syntax.Directive[], route: string) => Directives
+  dispose: () => void
 }
 
 export interface DirectiveSet {
   family: DirectiveFamily
   directives: any[]
+
+  /** qualified directive names, e.g. `auth:id` */
+  names?: string[]
 }
 
 export interface DirectiveFamily<TDirective = any, TExtension = any> {
@@ -23,6 +31,18 @@ export interface DirectiveFamily<TDirective = any, TExtension = any> {
 
   create: (name: string, ...rest: any[]) => TDirective
 
+  /**
+   * Called once per gateway with what the host provides and how the gateway is configured,
+   * before any directive is created.
+   */
+  mount?: (host: Host, options: Options) => void
+
+  /**
+   * Puts the directives of one route in the order they must run in. Called once, when
+   * the set is built — the order cannot depend on the request.
+   */
+  arrange?: (directives: TDirective[]) => void
+
   preflight?: (directives: TDirective[],
     request: Context & TExtension,
     parameters: Parameter[]) => Output | Promise<Output>
@@ -30,4 +50,6 @@ export interface DirectiveFamily<TDirective = any, TExtension = any> {
   settle?: (directives: TDirective[],
     request: Context & TExtension,
     response: OutgoingMessage) => void | Promise<void>
+
+  dispose?: (directives: TDirective[]) => void
 }

package/source/RTD/Endpoint.ts

@@ -1,10 +1,13 @@
-import { type Context } from './Context'
-import type * as http from '../HTTP'
-import type * as syntax from './syntax'
-import type * as RTD from './index'
+import { type Context } from './Context.js'
+import type * as http from '../HTTP/index.js'
+import type * as syntax from './syntax/index.js'
+import type * as RTD from './index.js'
 
 export interface Endpoint {
   call: (context: http.Context, parameters: RTD.Parameter[]) => Promise<http.OutgoingMessage>
+
+  explain: (parameters: RTD.Parameter[]) => Promise<unknown>
+
   close: () => Promise<void>
 }
 

package/source/RTD/Match.ts

@@ -1,4 +1,4 @@
-import { type Node } from './Node'
+import { type Node } from './Node.js'
 
 export interface Match {
   node: Node

package/source/RTD/Method.ts

@@ -1,15 +1,31 @@
-import type { Endpoint } from './Endpoint'
-import type { Directives } from './Directives'
+import type { Parameter } from './Match.js'
+import type { Endpoint } from './Endpoint.js'
+import type { Directives } from './Directives.js'
 
 export class Method {
   public readonly endpoint: Endpoint | null
   public readonly directives: Directives
+  private introspection: unknown | null = null
+  private introspecting: Promise<unknown> | null = null
 
   public constructor (endpoint: Endpoint | null, directives: Directives) {
     this.endpoint = endpoint
     this.directives = directives
   }
 
+  public async explain (parameters: Parameter[]): Promise<unknown> {
+    if (this.introspection !== null)
+      return this.introspection
+
+    if (this.introspecting === null)
+      // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+      this.introspecting = this.endpoint?.explain(parameters)!
+
+    this.introspection = await this.introspecting
+
+    return this.introspection
+  }
+
   public async close (): Promise<void> {
     await this.endpoint?.close()
   }

package/source/RTD/Node.ts

@@ -1,18 +1,21 @@
-import { type Route } from './Route'
-import { type Methods } from './Method'
-import { type Match, type Parameter } from './Match'
+import { type Route } from './Route.js'
+import { type Methods } from './Method.js'
+import { type Match, type Parameter } from './Match.js'
 
 export class Node {
   public intermediate: boolean
+  public forward: string | null
+  public expiration: number
   public methods: Methods
   private readonly protected: boolean
   private routes: Route[]
 
-  public constructor
-  (routes: Route[], methods: Methods, properties: Properties) {
+  public constructor (routes: Route[], methods: Methods, properties: Properties) {
     this.routes = routes
     this.methods = methods
     this.protected = properties.protected
+    this.forward = properties.forward ?? null
+    this.expiration = properties.expiration ?? Infinity
     this.intermediate = this.routes.findIndex((route) => route.root) !== -1
 
     this.sort()
@@ -20,7 +23,8 @@ export class Node {
 
   public match (fragments: string[], parameters: Parameter[] = []): Match | null {
     for (const route of this.routes) {
-      const match = route.match(fragments, parameters)
+      const params = parameters.slice()
+      const match = route.match(fragments, params)
 
       if (match !== null)
         return match
@@ -29,56 +33,94 @@ export class Node {
     return null
   }
 
-  public merge (node: Node): void {
+  /**
+   * Returns the nodes the merged branch has landed on, so that its expiration
+   * can later be extended without rebuilding anything.
+   */
+  public merge (node: Node): Node[] {
     this.intermediate = node.intermediate
 
-    if (!this.protected)
-      this.replace(node)
-    else
-      this.append(node)
+    const nodes = this.protected ? this.append(node) : this.replace(node)
 
     this.sort()
+
+    return nodes
+  }
+
+  public touch (expiration: number): void {
+    if (!this.protected)
+      this.expiration = expiration
   }
 
-  private replace (node: Node): void {
+  public async explain (parameters: Parameter[]): Promise<Record<string, unknown>> {
+    const methods: Record<string, unknown> = {}
+
+    const explained = Object.entries(this.methods)
+      .map(async ([verb, method]) =>
+        (methods[verb] = await method.explain(parameters)))
+
+    await Promise.all(explained)
+
+    return methods
+  }
+
+  private replace (node: Node): Node[] {
     const methods = Object.values(this.methods)
 
     this.routes = node.routes
     this.methods = node.methods
+    this.expiration = node.expiration
+    this.forward = node.forward
 
+    // race condition is really unlikely
     for (const method of methods)
       void method.close()
 
-    // race condition is really unlikely
+    return this.nodes()
   }
 
-  private append (node: Node): void {
+  private append (node: Node): Node[] {
+    const nodes: Node[] = []
+
     for (const route of node.routes)
-      this.mergeRoute(route)
+      nodes.push(...this.route(route))
 
     for (const [verb, method] of Object.entries(node.methods))
-      if (verb in this.methods)
-        console.warn(`Overriding of the protected method ${verb} is not permitted.`)
-      else
-        this.methods[verb] = method
+      this.methods[verb] = method
+
+    return nodes
   }
 
-  private mergeRoute (candidate: Route): void {
+  private route (candidate: Route): Node[] {
     for (const route of this.routes)
-      if (candidate.equals(route)) {
-        route.merge(candidate)
-
-        return
-      }
+      if (candidate.equals(route))
+        return route.merge(candidate)
 
     this.routes.push(candidate)
+
+    return candidate.node.nodes()
+  }
+
+  private nodes (): Node[] {
+    const nodes: Node[] = [this]
+
+    for (const route of this.routes)
+      nodes.push(...route.node.nodes())
+
+    return nodes
   }
 
   private sort (): void {
-    this.routes.sort((a, b) => a.variables - b.variables)
+    this.routes.sort((a, b) => {
+      return a.variables === b.variables
+        ? b.segments.length - a.segments.length // routes with more segments should be matched first
+        : a.variables - b.variables // routes with more variables should be matched last
+    })
   }
 }
 
 export interface Properties {
   protected: boolean
+  forward?: string
+  expiration?: number
 }