@toa.io/extensions.exposition 1.0.0-alpha.6 → 1.0.0-alpha.61

package/source/Mapping.ts

@@ -1,50 +1,92 @@
 import { type Parameter } from './RTD'
 import { Query } from './Query'
+import type { Introspection, Schema } from './Introspection'
+import type { QueryString } from './Query'
 import type * as http from './HTTP'
 import type * as syntax from './RTD/syntax'
 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
 
-    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 fit (input: any, query: http.Query, parameters: Parameter[]): core.Request {
+    const request: core.Request = {}
+    const qs = this.query.fit(query, parameters)
 
-  public constructor (query: Query) {
-    super()
+    if (input === undefined && qs.parameters !== null)
+      input = {}
 
-    this.query = query
-  }
+    this.assign(input, qs)
 
-  public fit (input: any, qs: http.Query, parameters: Parameter[]): core.Request {
-    const query = this.query.fit(qs, parameters)
+    if (input !== undefined)
+      request.input = input
 
-    return {
-      input,
-      query
-    }
+    if (qs.query !== null)
+      request.query = qs.query
+
+    return request
   }
 }
 
 class InputMapping extends Mapping {
-  public fit (input: any, _: unknown, parameters: Parameter[]): core.Request {
-    if (input === undefined && parameters.length > 0)
+  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 || 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 route parameters')
+
       for (const parameter of parameters)
         input[parameter.name] = parameter.value
+    }
 
-    return { input }
+    this.assign(input, qs)
+
+    if (input !== undefined)
+      request.input = input
+
+    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

@@ -16,7 +16,7 @@ it('should combine request criteria', async () => {
   const instance = new Query(query)
   const result = instance.fit({ criteria: 'qux==4' }, parameters)
 
-  expect(result.criteria).toStrictEqual('(foo==1);(bar==2;baz==3);(qux==4)')
+  expect(result.query!.criteria).toStrictEqual('(bar==2;baz==3);(foo==1);(qux==4)')
 })
 
 it('should set id parameter as query.id', async () => {
@@ -32,6 +32,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)
+  expect(result.query!.criteria).toBeUndefined()
+  expect(result.query!.id).toStrictEqual(id)
 })

package/source/Query.ts

@@ -1,43 +1,111 @@
+import assert from 'node:assert'
 import * as http from './HTTP'
 import { type Parameter } from './RTD'
 import * as schemas from './schemas'
+import { queryable } from './Mapping'
+import type { Introspection, Schema } from './Introspection'
 import type * as syntax from './RTD/syntax'
 import type * as core from '@toa.io/core'
 
 export class Query {
   private readonly query: syntax.Query
   private readonly closed: boolean = false
+  private readonly prepend: ',' | ';' = ';'
+  private readonly queryable: boolean
 
   public constructor (query: syntax.Query) {
-    if (query.criteria !== undefined) {
-      const open = query.criteria[query.criteria.length - 1] === ';'
-
-      if (open) query.criteria = query.criteria.slice(0, -1)
-      else this.closed = true
+    this.queryable = queryable(query)
+
+    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[]): core.Query {
-    const error = schemas.querystring.fit(query)
+  public fit (query: http.Query, parameters: Parameter[]): QueryString {
+    const qs = this.split(query)
+
+    if (qs.query !== null) {
+      const error = schemas.querystring.fit(qs.query)
 
-    if (error !== null)
-      throw new http.BadRequest('Query ' + error.message)
+      if (error !== null)
+        throw new http.BadRequest('Query ' + error.message)
 
-    this.fitCriteria(query, parameters)
-    this.fitRanges(query)
-    this.fitSort(query)
+      this.fitCriteria(qs.query, parameters)
+      this.fitRanges(qs.query)
+      this.fitSort(qs.query)
+    }
 
-    return query as core.Query
+    return {
+      query: qs.query as core.Query,
+      parameters: qs.parameters
+    }
   }
 
-  private fitCriteria (query: http.Query, parameters: Parameter[]): void {
-    const criteria: string[] = []
+  public explain (introspection: Introspection): Record<string, Schema> | null {
+    if (this.query?.parameters === undefined || introspection.input?.type !== 'object')
+      return null
 
-    if (this.query.criteria !== undefined)
-      criteria.push(this.query.criteria)
+    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]
+    }
+
+    return 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 (!this.queryable)
+      query = null!
+
+    return {
+      query,
+      parameters
+    }
+  }
+
+  private fitCriteria (query: http.Query, parameters: Parameter[]): void {
+    const groups: CriteriaGroup[] = []
     const idx = parameters.findIndex((parameter) => parameter.name === 'id')
 
     if (idx !== -1) {
@@ -47,32 +115,36 @@ export class Query {
     }
 
     if (parameters.length > 0) {
-      const chunks = parameters
+      const criteria = parameters
         .map(({ name, value }) => `${name}==${value}`)
         .join(';')
 
-      criteria.push(chunks)
+      groups.push({ criteria, operator: this.prepend })
     }
 
+    if (this.query.criteria !== undefined)
+      groups.push({ criteria: this.query.criteria, operator: ';' })
+
     if (query.criteria !== undefined)
-      if (this.closed) throw new http.BadRequest('Query criteria is closed.')
-      else criteria.push(query.criteria)
-
-    switch (criteria.length) {
-      case 0:
-        break
-      case 1:
-        query.criteria = criteria[0]
-        break
-      default:
-        query.criteria = '(' + criteria.join(');(') + ')'
-        break
-    }
+      if (this.closed)
+        throw new http.BadRequest('Query criteria is closed')
+      else
+        groups.push({ criteria: query.criteria, operator: WHATEVER })
+
+    if (groups.length > 0)
+      query.criteria = groups.reduce((acc, { criteria, operator }, i) => {
+        return i === groups.length - 1
+          ? `${acc}(${criteria})`
+          : `${acc}(${criteria})${operator}`
+      }, '')
   }
 
   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
@@ -99,7 +171,19 @@ function fit (string: string, range: [number, number], name: string): number {
 
   if (number < range[0] || number > range[1])
     throw new http.BadRequest(`Query ${name} must be between ` +
-      `${range[0]} and ${range[1]} inclusive.`)
+      `${range[0]} and ${range[1]} inclusive`)
 
   return number
 }
+
+const WHATEVER = ';'
+
+interface CriteriaGroup {
+  criteria: string
+  operator: ',' | ';'
+}
+
+export interface QueryString {
+  query: core.Query | null
+  parameters: Record<string, string> | null
+}

package/source/RTD/Endpoint.ts

@@ -5,6 +5,9 @@ import type * as RTD from './index'
 
 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/Method.ts

@@ -1,15 +1,31 @@
+import type { Parameter } from './Match'
 import type { Endpoint } from './Endpoint'
 import type { Directives } from './Directives'
 
 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

@@ -4,6 +4,7 @@ import { type Match, type Parameter } from './Match'
 
 export class Node {
   public intermediate: boolean
+  public forward: string | null
   public methods: Methods
   private readonly protected: boolean
   private routes: Route[]
@@ -13,6 +14,7 @@ export class Node {
     this.routes = routes
     this.methods = methods
     this.protected = properties.protected
+    this.forward = properties.forward ?? null
     this.intermediate = this.routes.findIndex((route) => route.root) !== -1
 
     this.sort()
@@ -20,7 +22,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
@@ -32,38 +35,46 @@ export class Node {
   public merge (node: Node): void {
     this.intermediate = node.intermediate
 
-    if (!this.protected)
-      this.replace(node)
-    else
+    if (this.protected)
       this.append(node)
+    else
+      this.replace(node)
 
     this.sort()
   }
 
+  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): void {
     const methods = Object.values(this.methods)
 
     this.routes = node.routes
     this.methods = node.methods
 
+    // race condition is really unlikely
     for (const method of methods)
       void method.close()
-
-    // race condition is really unlikely
   }
 
   private append (node: Node): void {
     for (const route of node.routes)
-      this.mergeRoute(route)
+      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
   }
 
-  private mergeRoute (candidate: Route): void {
+  private route (candidate: Route): void {
     for (const route of this.routes)
       if (candidate.equals(route)) {
         route.merge(candidate)
@@ -75,10 +86,15 @@ export class Node {
   }
 
   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
 }

package/source/RTD/Route.ts

@@ -5,7 +5,7 @@ import { type Match, type Parameter } from './Match'
 export class Route {
   public readonly root: boolean
   public readonly variables: number = 0
-  private readonly segments: Segment[]
+  public readonly segments: Segment[]
   private readonly node: Node
 
   public constructor (segments: Segment[], node: Node) {
@@ -31,8 +31,10 @@ export class Route {
 
     const exact = this.segments.length === fragments.length
 
-    if (exact && !this.node.intermediate) return { node: this.node, parameters }
-    else return this.matchNested(fragments, parameters)
+    if (exact && !this.node.intermediate)
+      return { node: this.node, parameters }
+    else
+      return this.matchNested(fragments, parameters)
   }
 
   public equals (route: Route): boolean {
@@ -52,7 +54,6 @@ export class Route {
 
   private matchNested (fragments: string[], parameters: Parameter[]): Match | null {
     fragments = fragments.slice(this.segments.length)
-    parameters = parameters.slice()
 
     return this.node.match(fragments, parameters)
   }

package/source/RTD/factory.ts

@@ -17,7 +17,10 @@ export function createNode (node: syntax.Node, context: Context): Node {
   for (const method of node.methods)
     methods[method.verb] = createMethod(method, context)
 
-  const properties: Properties = { protected: node.protected ?? context.protected }
+  const properties: Properties = {
+    protected: node.protected ?? context.protected,
+    forward: node.forward
+  }
 
   return new Node(routes, methods, properties)
 }
@@ -33,7 +36,7 @@ function createRoute (route: syntax.Route, context: Context): Route {
 }
 
 function createMethod (method: syntax.Method, context: Context): Method {
-  const stack = context.directives.stack.concat(method.directives.reverse())
+  const stack = method.directives.concat(context.directives.stack)
   const directives = context.directives.factory.create(stack)
 
   const endpoint = method.mapping?.endpoint === undefined

package/source/RTD/syntax/parse.ts

@@ -17,42 +17,56 @@ export function parse (input: object, shortcuts?: Shortcuts): Node {
   return node
 }
 
-function parseNode (input: object, shortcuts?: Shortcuts): Node {
+function parseNode (input: object | string, shortcuts?: Shortcuts): Node {
   const node = createNode()
 
-  for (const [key, value] of Object.entries(input)) {
-    if (PROPERTIES.includes(key as keyof Node)) {
-      node[key as keyof Node] = value
+  if (typeof input === 'string') {
+    node.forward = input
 
-      continue
-    }
+    return node
+  }
 
-    if (key[0] === '/') {
-      const route = parseRoute(key, value as Node, shortcuts)
+  for (const [key, value] of Object.entries(input) as Array<[keyof Node, unknown]>)
+    switch (key) {
+      case 'protected':
+      case 'isolated':
+        node[key] = value as boolean
+        break
+      case 'forward':
+        node[key] = value as string
+        break
 
-      node.routes.push(route)
+      default:
+        // eslint-disable-next-line max-depth
+        if (key[0] === '/') {
+          const route = parseRoute(key, value as Node, shortcuts)
 
-      continue
-    }
+          node.routes.push(route)
 
-    if (verbs.has(key)) {
-      const method = parseMethod(key, value as Mapping, shortcuts)
+          continue
+        }
 
-      node.methods.push(method)
+        // eslint-disable-next-line max-depth
+        if (verbs.has(key)) {
+          const method = parseMethod(key, value as Mapping, shortcuts)
 
-      continue
-    }
+          node.methods.push(method)
 
-    const directive = parseDirective(key, value, shortcuts)
+          continue
+        }
 
-    if (directive !== null) {
-      node.directives.push(directive)
+        // eslint-disable-next-line no-case-declarations
+        const directive = parseDirective(key, value, shortcuts)
 
-      continue
-    }
+        // eslint-disable-next-line max-depth
+        if (directive !== null) {
+          node.directives.push(directive)
 
-    throw new Error(`RTD parse error: unknown key '${key}'.`)
-  }
+          continue
+        }
+
+        throw new Error(`RTD parse error: unknown key '${key}'.`)
+    }
 
   return node
 }
@@ -149,6 +163,5 @@ function expandRange (range: number): Range {
 }
 
 const DIRECTIVE_RX = /^(?<family>\w{1,32}):(?<name>\w{1,32})$/
-const PROPERTIES: Array<keyof Node> = ['protected', 'isolated']
 
 export type Shortcuts = Map<string, string>

package/source/RTD/syntax/types.ts

@@ -1,6 +1,7 @@
 export interface Node {
   protected?: boolean
   isolated?: boolean
+  forward?: string
   routes: Route[]
   methods: Method[]
   directives: Directive[]
@@ -27,17 +28,18 @@ export interface Mapping {
   namespace?: string
   component?: string
   endpoint: string
-  query?: Query
+  query?: Query | null
 }
 
 export interface Query {
   id?: string
   criteria?: string
   sort?: string
-  omit: Range
-  limit: Range
+  omit?: Range
+  limit?: Range
   selectors?: string[]
   projection?: string[]
+  parameters?: string[]
 }
 
 export interface Range {
@@ -45,4 +47,4 @@ export interface Range {
   range: [number, number]
 }
 
-export const verbs = new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'])
+export const verbs = new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'LOCK', 'UNLOCK'])

package/source/Remotes.ts

@@ -1,24 +1,17 @@
-import { Locator, Connector, type Component } from '@toa.io/core'
+import { Locator, Connector, type Remote } from '@toa.io/core'
 import { type Bootloader } from './Factory'
 
 export class Remotes extends Connector {
   private readonly boot: Bootloader
-  private readonly remotes: Record<string, Promise<Component>> = {}
 
   public constructor (boot: Bootloader) {
     super()
     this.boot = boot
   }
 
-  public async discover (namespace: string, name: string): Promise<Component> {
+  public async discover (namespace: string, name: string): Promise<Remote> {
     const locator = new Locator(name, namespace)
 
-    this.remotes[locator.id] ??= this.create(locator)
-
-    return await this.remotes[locator.id]
-  }
-
-  private async create (locator: Locator): Promise<Component> {
     const remote = await this.boot.remote(locator)
 
     this.depends(remote)