@toa.io/extensions.exposition 1.0.0-alpha.30 → 1.0.0-alpha.301

package/source/Query.ts

@@ -1,116 +0,0 @@
-import * as http from './HTTP'
-import { type Parameter } from './RTD'
-import * as schemas from './schemas'
-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: ',' | ';' = ';'
-
-  public constructor (query: syntax.Query) {
-    if (query.criteria !== undefined) {
-      if (query.criteria.endsWith(';'))
-        query.criteria = query.criteria.slice(0, -1)
-      else
-        this.closed = true
-
-      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)
-
-    if (error !== null)
-      throw new http.BadRequest('Query ' + error.message)
-
-    this.fitCriteria(query, parameters)
-    this.fitRanges(query)
-    this.fitSort(query)
-
-    return query as core.Query
-  }
-
-  private fitCriteria (query: http.Query, parameters: Parameter[]): void {
-    const groups: CriteriaGroup[] = []
-    const idx = parameters.findIndex((parameter) => parameter.name === 'id')
-
-    if (idx !== -1) {
-      query.id = parameters[idx].value
-
-      parameters.splice(idx, 1)
-    }
-
-    if (parameters.length > 0) {
-      const criteria = parameters
-        .map(({ name, value }) => `${name}==${value}`)
-        .join(';')
-
-      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
-        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
-
-    if (qs.limit !== undefined)
-      query.limit = fit(qs.limit, this.query.limit.range, 'limit')
-    else
-      query.limit = this.query.limit.value
-
-    if (qs.omit !== undefined)
-      query.omit = fit(qs.omit, this.query.omit.range, 'omit')
-  }
-
-  private fitSort (qs: http.Query): void {
-    const query = qs as core.Query
-
-    if (qs.sort === undefined && this.query.sort === undefined)
-      return
-
-    const sort = (this.query.sort ?? '') + (qs.sort ?? '')
-
-    query.sort = sort.split(';')
-  }
-}
-
-function fit (string: string, range: [number, number], name: string): number {
-  const number = parseInt(string)
-
-  if (number < range[0] || number > range[1])
-    throw new http.BadRequest(`Query ${name} must be between ` +
-      `${range[0]} and ${range[1]} inclusive`)
-
-  return number
-}
-
-const WHATEVER = ';'
-
-interface CriteriaGroup {
-  criteria: string
-  operator: ',' | ';'
-}

package/source/RTD/Context.ts

@@ -1,13 +0,0 @@
-import { type DirectiveFactory } from './Directives'
-import { type EndpointsFactory } from './Endpoint'
-import type { Directive } from './syntax'
-
-export interface Context<TExtension = any> {
-  readonly protected: boolean
-  readonly endpoints: EndpointsFactory
-  readonly directives: {
-    readonly factory: DirectiveFactory
-    stack: Directive[]
-  }
-  readonly extension?: TExtension
-}

package/source/RTD/Directives.ts

@@ -1,33 +0,0 @@
-import type { Parameter } from './Match'
-import type * as syntax from './syntax'
-import type { Context, OutgoingMessage } from '../HTTP'
-import type { Output } from '../io'
-
-export interface Directives {
-  preflight: (context: Context, parameters: Parameter[]) => Promise<Output>
-  settle: (context: Context, response: OutgoingMessage) => Promise<void>
-}
-
-export interface DirectiveFactory {
-  create: (directives: syntax.Directive[]) => Directives
-}
-
-export interface DirectiveSet {
-  family: DirectiveFamily
-  directives: any[]
-}
-
-export interface DirectiveFamily<TDirective = any, TExtension = any> {
-  readonly name: string
-  readonly mandatory: boolean
-
-  create: (name: string, ...rest: any[]) => TDirective
-
-  preflight?: (directives: TDirective[],
-    request: Context & TExtension,
-    parameters: Parameter[]) => Output | Promise<Output>
-
-  settle?: (directives: TDirective[],
-    request: Context & TExtension,
-    response: OutgoingMessage) => void | Promise<void>
-}

package/source/RTD/Endpoint.ts

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

package/source/RTD/Match.ts

@@ -1,11 +0,0 @@
-import { type Node } from './Node'
-
-export interface Match {
-  node: Node
-  parameters: Parameter[]
-}
-
-export interface Parameter {
-  name: string
-  value: string
-}

package/source/RTD/Method.ts

@@ -1,18 +0,0 @@
-import type { Endpoint } from './Endpoint'
-import type { Directives } from './Directives'
-
-export class Method {
-  public readonly endpoint: Endpoint | null
-  public readonly directives: Directives
-
-  public constructor (endpoint: Endpoint | null, directives: Directives) {
-    this.endpoint = endpoint
-    this.directives = directives
-  }
-
-  public async close (): Promise<void> {
-    await this.endpoint?.close()
-  }
-}
-
-export type Methods = Record<string, Method>

package/source/RTD/Node.ts

@@ -1,84 +0,0 @@
-import { type Route } from './Route'
-import { type Methods } from './Method'
-import { type Match, type Parameter } from './Match'
-
-export class Node {
-  public intermediate: boolean
-  public methods: Methods
-  private readonly protected: boolean
-  private routes: Route[]
-
-  public constructor
-  (routes: Route[], methods: Methods, properties: Properties) {
-    this.routes = routes
-    this.methods = methods
-    this.protected = properties.protected
-    this.intermediate = this.routes.findIndex((route) => route.root) !== -1
-
-    this.sort()
-  }
-
-  public match (fragments: string[], parameters: Parameter[] = []): Match | null {
-    for (const route of this.routes) {
-      const match = route.match(fragments, parameters)
-
-      if (match !== null)
-        return match
-    }
-
-    return null
-  }
-
-  public merge (node: Node): void {
-    this.intermediate = node.intermediate
-
-    if (!this.protected)
-      this.replace(node)
-    else
-      this.append(node)
-
-    this.sort()
-  }
-
-  private replace (node: Node): void {
-    const methods = Object.values(this.methods)
-
-    this.routes = node.routes
-    this.methods = node.methods
-
-    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)
-
-    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
-  }
-
-  private mergeRoute (candidate: Route): void {
-    for (const route of this.routes)
-      if (candidate.equals(route)) {
-        route.merge(candidate)
-
-        return
-      }
-
-    this.routes.push(candidate)
-  }
-
-  private sort (): void {
-    this.routes.sort((a, b) => a.variables - b.variables)
-  }
-}
-
-export interface Properties {
-  protected: boolean
-}

package/source/RTD/Route.ts

@@ -1,59 +0,0 @@
-import { type Node } from './Node'
-import { type Segment } from './segment'
-import { type Match, type Parameter } from './Match'
-
-export class Route {
-  public readonly root: boolean
-  public readonly variables: number = 0
-  private readonly segments: Segment[]
-  private readonly node: Node
-
-  public constructor (segments: Segment[], node: Node) {
-    this.root = segments.length === 0
-    this.segments = segments
-    this.node = node
-
-    for (const segment of segments)
-      if (segment.fragment === null)
-        this.variables++
-  }
-
-  public match (fragments: string[], parameters: Parameter[]): Match | null {
-    for (let i = 0; i < this.segments.length; i++) {
-      const segment = this.segments[i]
-
-      if (segment.fragment !== null && segment.fragment !== fragments[i])
-        return null
-
-      if (segment.fragment === null && segment.placeholder !== null)
-        parameters.push({ name: segment.placeholder, value: fragments[i] })
-    }
-
-    const exact = this.segments.length === fragments.length
-
-    if (exact && !this.node.intermediate) return { node: this.node, parameters }
-    else return this.matchNested(fragments, parameters)
-  }
-
-  public equals (route: Route): boolean {
-    if (route.segments.length !== this.segments.length)
-      return false
-
-    for (let i = 0; i < this.segments.length; i++)
-      if (this.segments[i].fragment !== route.segments[i].fragment)
-        return false
-
-    return true
-  }
-
-  public merge (route: Route): void {
-    this.node.merge(route.node)
-  }
-
-  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/Tree.ts

@@ -1,58 +0,0 @@
-import { createNode } from './factory'
-import { fragment } from './segment'
-import type { Node } from './Node'
-import type { Match } from './Match'
-import type { Context } from './Context'
-import type { DirectiveFactory } from './Directives'
-import type { EndpointsFactory } from './Endpoint'
-import type * as syntax from './syntax'
-
-export class Tree {
-  private readonly root: syntax.Node
-  private readonly trunk: Node
-  private readonly endpoints: EndpointsFactory
-  private readonly directives: DirectiveFactory
-
-  public constructor
-  (node: syntax.Node, endpoints: EndpointsFactory, directives: DirectiveFactory) {
-    this.endpoints = endpoints
-    this.directives = directives
-    this.trunk = this.createNode(node, PROTECTED)
-    this.root = node
-  }
-
-  public match (path: string): Match | null {
-    if (path === '/')
-      return {
-        node: this.trunk,
-        parameters: []
-      }
-
-    const fragments = fragment(path)
-
-    return this.trunk.match(fragments)
-  }
-
-  public merge (node: syntax.Node, extension: any): void {
-    const branch = this.createNode(node, !PROTECTED, extension)
-
-    this.trunk.merge(branch)
-  }
-
-  private createNode
-  (node: syntax.Node, protect: boolean, extension?: any): Node {
-    const context: Context = {
-      protected: protect,
-      endpoints: this.endpoints,
-      directives: {
-        factory: this.directives,
-        stack: this.root?.directives ?? []
-      },
-      extension
-    }
-
-    return createNode(node, context)
-  }
-}
-
-const PROTECTED = true

package/source/RTD/factory.ts

@@ -1,44 +0,0 @@
-import { Node, type Properties } from './Node'
-import { Route } from './Route'
-import { segment } from './segment'
-import { Method, type Methods } from './Method'
-import type { Context } from './Context'
-import type * as syntax from './syntax'
-
-export function createNode (node: syntax.Node, context: Context): Node {
-  if (node.isolated === true)
-    context.directives.stack = node.directives
-  else
-    context.directives.stack = node.directives.concat(context.directives.stack)
-
-  const routes: Route[] = node.routes.map((route) => createRoute(route, context))
-  const methods: Methods = {}
-
-  for (const method of node.methods)
-    methods[method.verb] = createMethod(method, context)
-
-  const properties: Properties = { protected: node.protected ?? context.protected }
-
-  return new Node(routes, methods, properties)
-}
-
-function createRoute (route: syntax.Route, context: Context): Route {
-  const stack = context.directives.stack.slice()
-  const segments = segment(route.path)
-  const node = createNode(route.node, context)
-
-  context.directives.stack = stack // restore
-
-  return new Route(segments, node)
-}
-
-function createMethod (method: syntax.Method, context: Context): Method {
-  const stack = method.directives.concat(context.directives.stack)
-  const directives = context.directives.factory.create(stack)
-
-  const endpoint = method.mapping?.endpoint === undefined
-    ? null
-    : context.endpoints.create(method, context)
-
-  return new Method(endpoint, directives)
-}

package/source/RTD/index.ts

@@ -1,8 +0,0 @@
-export * from './Tree'
-export * from './Node'
-export * from './Match'
-export * from './Method'
-export * from './Context'
-export * from './Endpoint'
-export * from './Directives'
-export * as syntax from './syntax'

package/source/RTD/segment.test.ts

@@ -1,32 +0,0 @@
-import { segment, fragment } from './segment'
-
-it('should return segments', async () => {
-  const segments = segment('/foo/bar/')
-
-  expect(segments).toHaveLength(2)
-  expect(segments[0].fragment).toBe('foo')
-  expect(segments[1].fragment).toBe('bar')
-})
-
-it('should parse placeholders', async () => {
-  const segments = segment('/foo/:id/')
-
-  expect(segments).toHaveLength(2)
-  expect(segments[0].fragment).toBe('foo')
-  expect(segments[1].fragment).toBeNull()
-
-  // helping typescript
-  if (segments[1].fragment !== null) throw new Error('?')
-
-  expect(segments[1].placeholder).toBe('id')
-})
-
-it('should handle root path', async () => {
-  expect(segment('/')).toStrictEqual([])
-})
-
-it('should split', async () => {
-  const parts = fragment('/foo/bar/')
-
-  expect(parts).toStrictEqual(['foo', 'bar'])
-})

package/source/RTD/segment.ts

@@ -1,26 +0,0 @@
-export function segment (path: string): Segment[] {
-  return fragment(path).map(parse)
-}
-
-export function fragment (path: string): string[] {
-  const parts = path.split('/')
-
-  // trailing slash
-  if (parts[parts.length - 1] === '') parts.length--
-
-  // leading slash
-  return parts.splice(1)
-}
-
-function parse (segment: string): Segment {
-  if (segment[0] === ':') return { fragment: null, placeholder: segment.substring(1) }
-  else if (segment === '*') return { fragment: null, placeholder: null }
-  else return { fragment: segment }
-}
-
-export type Segment = {
-  fragment: string
-} | {
-  fragment: null
-  placeholder: string | null
-}

package/source/RTD/syntax/index.ts

@@ -1,2 +0,0 @@
-export * from './parse'
-export * from './types'