@toa.io/extensions.exposition 1.0.0-alpha.3 → 1.0.0-alpha.300

package/source/HTTP/formats/msgpack.ts

@@ -1,16 +0,0 @@
-import { type Buffer } from 'node:buffer'
-import { pack, unpack } from 'msgpackr'
-
-export function decode (buffer: Buffer): any {
-  return unpack(buffer)
-}
-
-export function encode (value: any): Buffer {
-  if (typeof value === 'object' && value !== null)
-    Object.setPrototypeOf(value, null)
-
-  return pack(value)
-}
-
-export const type = 'application/msgpack'
-export const multipart = 'multipart/msgpack'

package/source/HTTP/formats/text.ts

@@ -1,12 +0,0 @@
-import { Buffer } from 'node:buffer'
-
-export const type = 'text/plain'
-export const multipart = 'multipart/text'
-
-export function decode (buffer: Buffer): any {
-  return buffer.toString()
-}
-
-export function encode (value: { toString: () => string }): Buffer {
-  return Buffer.from(value.toString())
-}

package/source/HTTP/formats/yaml.ts

@@ -1,17 +0,0 @@
-import { Buffer } from 'node:buffer'
-import * as yaml from 'js-yaml'
-
-export const type = 'application/yaml'
-export const multipart = 'multipart/yaml'
-
-export function decode (buffer: Buffer): any {
-  const text = buffer.toString()
-
-  return yaml.load(text)
-}
-
-export function encode (value: any): Buffer {
-  const text = yaml.dump(value, { lineWidth: -1, noRefs: true })
-
-  return Buffer.from(text)
-}

package/source/HTTP/index.ts

@@ -1,3 +0,0 @@
-export * from './Server'
-export * from './messages'
-export * from './exceptions'

package/source/HTTP/messages.test.ts

@@ -1,70 +0,0 @@
-import { generate } from 'randomstring'
-import * as msgpack from 'msgpackr'
-import { read } from './messages'
-import { createRequest } from './Server.fixtures'
-import { BadRequest, UnsupportedMediaType } from './exceptions'
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-describe('read', () => {
-  it('should parse application/json', async () => {
-    const path = generate()
-    const headers = { 'content-type': 'application/json' }
-    const input = { [generate()]: generate() }
-    const json = JSON.stringify(input)
-    const request = createRequest({ path, headers }, json)
-    const output = await read(request)
-
-    expect(output).toStrictEqual(input)
-  })
-
-  it('should parse application/yaml', async () => {
-    const path = generate()
-    const headers = { 'content-type': 'application/yaml' }
-    const yaml = 'foo: 1'
-    const request = createRequest({ path, headers }, yaml)
-    const value = await read(request)
-
-    expect(value).toStrictEqual({ foo: 1 })
-  })
-
-  it('should parse application/mskpack', async () => {
-    const path = generate()
-    const headers = { 'content-type': 'application/msgpack' }
-    const input = { [generate()]: generate() }
-    const msg = msgpack.encode(input)
-    const request = createRequest({ path, headers }, msg)
-    const output = await read(request)
-
-    expect(output).toStrictEqual(input)
-  })
-
-  it('should parse text/plain', async () => {
-    const path = generate()
-    const headers = { 'content-type': 'text/plain' }
-    const input = generate()
-    const request = createRequest({ path, headers }, input)
-    const output = await read(request)
-
-    expect(output).toStrictEqual(input)
-  })
-
-  it('should throw on unsupported request media type', async () => {
-    const path = generate()
-    const headers = { 'content-type': 'wtf/' + generate() }
-    const request = createRequest({ path, headers })
-
-    await expect(read(request)).rejects.toThrow(UnsupportedMediaType)
-  })
-
-  it('should throw on malformed content', async () => {
-    const path = generate()
-    const text = '{ "foo": "val... oops '
-    const headers = { 'content-type': 'application/json' }
-    const request = createRequest({ path, headers }, text)
-
-    await expect(read(request)).rejects.toThrow(BadRequest)
-  })
-})

package/source/HTTP/messages.ts

@@ -1,126 +0,0 @@
-import { type IncomingHttpHeaders } from 'node:http'
-import { Readable } from 'node:stream'
-import { type Request, type Response } from 'express'
-import { buffer } from '@toa.io/streams'
-import { formats } from './formats'
-import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions'
-import type { ParsedQs } from 'qs'
-import type { Format } from './formats'
-
-export function write
-(request: IncomingMessage, response: Response, message: OutgoingMessage): void {
-  for (const transform of request.pipelines.response)
-    transform(message)
-
-  message.headers?.forEach((value, key) => response.set(key, value))
-
-  if (message.body instanceof Readable)
-    stream(message, request, response)
-  else
-    send(message, request, response)
-}
-
-export async function read (request: Request): Promise<any> {
-  const type = request.headers['content-type']
-
-  if (type === undefined)
-    return undefined
-
-  if (!(type in formats))
-    throw new UnsupportedMediaType()
-
-  const format = formats[type]
-
-  const buf = await buffer(request)
-
-  try {
-    return format.decode(buf)
-  } catch {
-    throw new BadRequest()
-  }
-}
-
-function send (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
-  if (message.body === undefined || message.body === null) {
-    response.end()
-
-    return
-  }
-
-  if (request.encoder === null)
-    throw new NotAcceptable()
-
-  const buf = request.encoder.encode(message.body)
-
-  response
-    .set('content-type', request.encoder.type)
-    .append('vary', 'accept')
-    .end(buf)
-}
-
-function stream
-(message: OutgoingMessage, request: IncomingMessage, response: Response): void {
-  const encoded = message.headers !== undefined && message.headers.has('content-type')
-
-  if (encoded)
-    pipe(message, response)
-  else
-    multipart(message, request, response)
-
-  message.body.on('error', (e: Error) => {
-    console.error(e)
-    response.end()
-  })
-}
-
-function pipe (message: OutgoingMessage, response: Response): void {
-  message.headers?.forEach((value, key) => response.set(key, value))
-  message.body.pipe(response)
-}
-
-function multipart (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
-  if (request.encoder === null)
-    throw new NotAcceptable()
-
-  const encoder = request.encoder
-
-  response.set('content-type', `${encoder.multipart}; boundary=${BOUNDARY}`)
-
-  message.body
-    .map((part: unknown) => Buffer.concat([CUT, encoder.encode(part)]))
-    .on('end', () => response.end(FINALCUT))
-    .pipe(response)
-}
-
-const BOUNDARY = 'cut'
-const CUT = Buffer.from(`--${BOUNDARY}\r\n`)
-const FINALCUT = Buffer.from(`--${BOUNDARY}--`)
-
-export interface IncomingMessage extends Request {
-  method: string
-  path: string
-  url: string
-  headers: IncomingHttpHeaders
-  query: Query
-  parse: <T> () => Promise<T>
-  encoder: Format | null
-  subtype: string | null
-  pipelines: {
-    body: Array<(input: unknown) => unknown>
-    response: Array<(output: OutgoingMessage) => void>
-  }
-}
-
-export interface OutgoingMessage {
-  status?: number
-  headers?: Headers
-  body?: any
-}
-
-export interface Query extends ParsedQs {
-  id?: string
-  criteria?: string
-  sort?: string
-  omit?: string
-  limit?: string
-}

package/source/Interception.ts

@@ -1,24 +0,0 @@
-import type { Input, Output } from './io'
-
-export class Interception implements Interceptor {
-  private readonly interceptors: Interceptor[]
-
-  public constructor (interceptors: Interceptor[]) {
-    this.interceptors = interceptors
-  }
-
-  public async intercept (input: Input): Promise<Output> {
-    for (const interceptor of this.interceptors) {
-      const output = await interceptor.intercept(input)
-
-      if (output !== null)
-        return output
-    }
-
-    return null
-  }
-}
-
-export interface Interceptor {
-  intercept: (input: Input) => Output | Promise<Output>
-}

package/source/Mapping.ts

@@ -1,51 +0,0 @@
-import { type Parameter } from './RTD'
-import { Query } 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()
-
-    const q = new Query(query)
-
-    return new QueryableMapping(q)
-  }
-
-  public abstract fit (input: any, qs: http.Query, parameters: Parameter[]): core.Request
-}
-
-class QueryableMapping extends Mapping {
-  private readonly query: Query
-
-  public constructor (query: Query) {
-    super()
-
-    this.query = query
-  }
-
-  public fit (input: any, qs: http.Query, parameters: Parameter[]): core.Request {
-    const query = this.query.fit(qs, parameters)
-
-    return { input, query }
-  }
-}
-
-class InputMapping extends Mapping {
-  public fit (input: any, _: unknown, parameters: Parameter[]): core.Request {
-    if (input === undefined && parameters.length > 0)
-      input = {}
-
-    if (typeof input === 'object')
-      this.assign(input, parameters)
-
-    return { input }
-  }
-
-  private assign (input: Record<string, any>, parameters: Parameter[]): void {
-    for (const parameter of parameters)
-      input[parameter.name] = parameter.value
-  }
-}

package/source/Query.test.ts

@@ -1,37 +0,0 @@
-import { Query } from './Query'
-import { type Parameter, type syntax } from './RTD'
-
-it('should combine request criteria', async () => {
-  const query: syntax.Query = {
-    criteria: 'foo==1;',
-    omit: { range: [0, 1] },
-    limit: { range: [0, 1] }
-  }
-
-  const parameters: Parameter[] = [
-    { name: 'bar', value: '2' },
-    { name: 'baz', value: '3' }
-  ]
-
-  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)')
-})
-
-it('should set id parameter as query.id', async () => {
-  const query: syntax.Query = {
-    omit: { range: [0, 1] },
-    limit: { range: [0, 1] }
-  }
-
-  const id = '87782631058445da81cb82f78b20c223'
-
-  const parameters: Parameter[] = [{ name: 'id', value: id }]
-
-  const instance = new Query(query)
-  const result = instance.fit({}, parameters)
-
-  expect(result.criteria).toBeUndefined()
-  expect(result.id).toStrictEqual(id)
-})

package/source/Query.ts

@@ -1,105 +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
-
-  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.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 criteria: string[] = []
-
-    if (this.query.criteria !== undefined)
-      criteria.push(this.query.criteria)
-
-    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 chunks = parameters
-        .map(({ name, value }) => `${name}==${value}`)
-        .join(';')
-
-      criteria.push(chunks)
-    }
-
-    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
-    }
-  }
-
-  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
-}

package/source/RTD/Context.ts

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

package/source/RTD/Directives.ts

@@ -1,9 +0,0 @@
-import type * as syntax from './syntax'
-
-export interface Directives<TDirective = any> {
-  merge: (directive: TDirective) => void
-}
-
-export interface DirectivesFactory<T = any> {
-  create: (directives: syntax.Directive[]) => T
-}

package/source/RTD/Endpoint.ts

@@ -1,11 +0,0 @@
-import { type Context } from './Context'
-import type * as syntax from './syntax'
-
-export interface Endpoint<T extends Endpoint = any> {
-  call: T['call']
-  close: () => Promise<void>
-}
-
-export interface EndpointsFactory<T extends Endpoint<T> = any> {
-  create: (method: syntax.Method, context: Context) => T
-}

package/source/RTD/Match.ts

@@ -1,16 +0,0 @@
-import { type Node } from './Node'
-import { type Directives } from './Directives'
-import { type Endpoint } from './Endpoint'
-
-export interface Match<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
-  node: Node<TEndpoint, TDirectives>
-  parameters: Parameter[]
-}
-
-export interface Parameter {
-  name: string
-  value: string
-}

package/source/RTD/Method.ts

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

package/source/RTD/Node.ts

@@ -1,85 +0,0 @@
-import { type Route } from './Route'
-import { type Methods } from './Method'
-import { type Match, type Parameter } from './Match'
-import { type Directives } from './Directives'
-import { type Endpoint } from './Endpoint'
-
-export class Node<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
-  public intermediate: boolean
-  public methods: Methods<TEndpoint, TDirectives>
-  private readonly protected: boolean
-  private routes: Route[]
-
-  public constructor
-  (routes: Route[], methods: Methods<TEndpoint, TDirectives>, 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<TEndpoint, TDirectives>): void {
-    this.intermediate = node.intermediate
-
-    if (!this.protected) this.replace(node)
-    else this.append(node)
-
-    this.sort()
-  }
-
-  private replace (node: Node<TEndpoint, TDirectives>): 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<TEndpoint, TDirectives>): 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
-}