@toa.io/extensions.exposition 1.0.0-alpha.31 → 1.0.0-alpha.310

package/source/HTTP/Server.ts

@@ -1,171 +0,0 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import * as http from 'node:http'
-import { once } from 'node:events'
-import { setTimeout } from 'node:timers/promises'
-import { Connector } from '@toa.io/core'
-import { type OutgoingMessage, write } from './messages'
-import { ClientError, Exception } from './exceptions'
-import { Context } from './Context'
-import type { IncomingMessage } from './Context'
-
-export class Server extends Connector {
-  private readonly server: http.Server = http.createServer()
-  private readonly properties: Properties
-  private readonly authorities: Record<string, string>
-  private process?: Processing
-  private ready: boolean = false
-  private startedAt: number = 0
-
-  private constructor (properties: Properties) {
-    super()
-
-    this.properties = properties
-    this.authorities = Object.fromEntries(Object.entries(properties.authorities).map(([key, value]) => [value, key]))
-
-    this.server.on('request', (req, res) => this.listener(req, res))
-  }
-
-  public static create (options: Options): Server {
-    const properties: Properties = Object.assign({}, DEFAULTS, options)
-
-    return new Server(properties)
-  }
-
-  public attach (process: Processing): void {
-    this.process = process
-  }
-
-  protected override async open (): Promise<void> {
-    this.startedAt = Date.now()
-    this.server.listen(this.properties.port)
-
-    await once(this.server, 'listening')
-
-    console.info('HTTP Server is listening')
-
-    await setTimeout(this.properties.delay)
-
-    this.ready = true
-
-    console.info('Ready')
-  }
-
-  protected override async close (): Promise<void> {
-    this.server.close()
-    this.ready = false
-
-    console.info('HTTP Server stopped accepting new connections')
-
-    await once(this.server, 'close')
-
-    console.info('HTTP Server has been stopped')
-  }
-
-  private listener (request: http.IncomingMessage, response: http.ServerResponse): void {
-    if (request.method === undefined || !this.properties.methods.has(request.method)) {
-      response.writeHead(501).end()
-
-      return
-    }
-
-    if (request.url === '/.ready') {
-      if (this.ready)
-        response.writeHead(200, { 'cache-control': 'no-store' }).end()
-      else {
-        const remaining = (Math.ceil((Date.now() - this.startedAt) / 1000)).toString()
-
-        response.writeHead(503, { 'retry-after': remaining }).end()
-      }
-
-      return
-    }
-
-    if (request.headers.host === undefined || !(request.headers.host in this.authorities)) {
-      response.writeHead(404).end('Unknown authority')
-
-      return
-    }
-
-    const authority = this.authorities[request.headers.host]
-    const context = new Context(authority, request as IncomingMessage, this.properties)
-
-    this.process!(context)
-      .then(this.success(context, response))
-      .catch(this.fail(context, response))
-  }
-
-  private success (context: Context, response: http.ServerResponse) {
-    return (message: OutgoingMessage) => {
-      let status = message.status
-
-      if (status === undefined)
-        if (message.body === null)
-          status = 404
-        else if (context.request.method === 'POST')
-          status = 201
-        else if (message.body === undefined)
-          status = 204
-        else
-          status = 200
-
-      response.statusCode = message.status = status
-      write(context, response, message)
-    }
-  }
-
-  private fail (context: Context, response: http.ServerResponse) {
-    return async (exception: Error) => {
-      if (!context.request.complete)
-        await adam(context.request)
-
-      response.statusCode = exception instanceof Exception ? exception.status : 500
-
-      const message: OutgoingMessage = { status: response.statusCode }
-      const verbose = exception instanceof ClientError || this.properties.debug
-
-      if (verbose)
-        message.body =
-          exception instanceof Exception
-            ? exception.body
-            : exception.stack ?? exception.message
-
-      write(context, response, message)
-    }
-  }
-}
-
-// https://github.com/whatwg/fetch/issues/1254
-async function adam (request: http.IncomingMessage): Promise<any> {
-  const devnull = fs.createWriteStream(os.devNull)
-
-  request.pipe(devnull)
-
-  return once(request, 'end')
-}
-
-export const PORT = 8000
-export const DELAY = 3 // seconds
-
-const DEFAULTS: Omit<Properties, 'authorities'> = {
-  methods: new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']),
-  debug: false,
-  trace: false,
-  port: PORT,
-  delay: DELAY * 1000
-}
-
-interface Properties {
-  authorities: Record<string, string>
-  methods: Set<string>
-  debug: boolean
-  trace: boolean
-  port: number
-  delay: number
-}
-
-export type Options = { authorities: Properties['authorities'] } & {
-  [K in Exclude<keyof Properties, 'authorities'>]?: Properties[K]
-}
-
-export type Processing = (input: Context) => Promise<OutgoingMessage>

package/source/HTTP/Timing.ts

@@ -1,40 +0,0 @@
-import { performance } from 'node:perf_hooks'
-import type { ServerResponse } from 'node:http'
-
-export class Timing {
-  private readonly skip: boolean
-  private readonly start = performance.now()
-  private readonly breakpoints: Breakpoint[] = []
-
-  public constructor (enabled: boolean) {
-    this.skip = !enabled
-  }
-
-  public async capture<T> (id: string, promise: Promise<T>): Promise<T> {
-    if (this.skip)
-      return promise
-
-    const start = performance.now()
-    const result = promise instanceof Promise ? await promise : promise
-
-    this.breakpoints.push({ id, duration: performance.now() - start })
-
-    return result
-  }
-
-  public append (response: ServerResponse): void {
-    if (this.skip)
-      return
-
-    this.breakpoints.push({ id: 'total', duration: performance.now() - this.start })
-
-    for (const breakpoint of this.breakpoints)
-      response.appendHeader('server-timing',
-        `${breakpoint.id};dur=${breakpoint.duration.toFixed(3)}`)
-  }
-}
-
-interface Breakpoint {
-  id: string
-  duration: number
-}

package/source/HTTP/exceptions.ts

@@ -1,73 +0,0 @@
-export class Exception extends Error {
-  public readonly status: number
-  public readonly body?: any
-
-  protected constructor (status: number, body?: any) {
-    super()
-    this.status = status
-    this.body = body
-  }
-}
-
-export class ClientError extends Exception {
-}
-
-export class BadRequest extends ClientError {
-  public constructor (body?: any) {
-    super(400, body)
-  }
-}
-
-export class Unauthorized extends ClientError {
-  public constructor (body?: any) {
-    super(401, body)
-  }
-}
-
-export class Forbidden extends ClientError {
-  public constructor (body?: any) {
-    super(403, body)
-  }
-}
-
-export class NotFound extends ClientError {
-  public constructor (body?: any) {
-    super(404, body)
-  }
-}
-
-export class Conflict extends ClientError {
-  public constructor (body?: any) {
-    super(409, body)
-  }
-}
-
-export class UnprocessableEntity extends ClientError {
-  public constructor (body?: any) {
-    super(422, body)
-  }
-}
-
-export class MethodNotAllowed extends ClientError {
-  public constructor () {
-    super(405)
-  }
-}
-
-export class NotAcceptable extends ClientError {
-  public constructor () {
-    super(406)
-  }
-}
-
-export class UnsupportedMediaType extends ClientError {
-  public constructor () {
-    super(415)
-  }
-}
-
-export class PreconditionFailed extends ClientError {
-  public constructor () {
-    super(412)
-  }
-}

package/source/HTTP/formats/index.ts

@@ -1,22 +0,0 @@
-import { type Buffer } from 'node:buffer'
-import * as json from './json'
-import * as yaml from './yaml'
-import * as msgpack from './msgpack'
-import * as text from './text'
-
-export const formats: Record<string, Format> = {
-  [msgpack.type]: msgpack,
-  [yaml.type]: yaml,
-  [json.type]: json,
-  [text.type]: text
-}
-
-export const types = Object.keys(formats)
-
-export interface Format {
-  readonly type: string
-  readonly multipart: string
-
-  encode: (value: any) => Buffer
-  decode: (buffer: Buffer) => any
-}

package/source/HTTP/formats/json.ts

@@ -1,16 +0,0 @@
-import { Buffer } from 'node:buffer'
-
-export const type = 'application/json'
-export const multipart = 'multipart/json'
-
-export function decode (buffer: Buffer): any {
-  const text = buffer.toString()
-
-  return JSON.parse(text)
-}
-
-export function encode (value: any): Buffer {
-  const text = JSON.stringify(value)
-
-  return Buffer.from(text)
-}

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,4 +0,0 @@
-export * from './Server'
-export * from './messages'
-export * from './exceptions'
-export * from './Context'

package/source/HTTP/messages.test.ts

@@ -1,89 +0,0 @@
-import { Readable } from 'node:stream'
-import { generate } from 'randomstring'
-import * as msgpack from 'msgpackr'
-import { read } from './messages'
-import { BadRequest, UnsupportedMediaType } from './exceptions'
-import { Timing } from './Timing'
-import type { Context } from './Context'
-
-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 context = createContext(path, headers, json)
-    const output = await read(context)
-
-    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 = createContext(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 = createContext(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 = createContext(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 = createContext(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 = createContext(path, headers, text)
-
-    await expect(read(request)).rejects.toThrow(BadRequest)
-  })
-})
-
-export function createContext
-(url: string, headers: Record<string, string> = {}, content: string | Buffer = ''):
-jest.MockedObject<Context> {
-  const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content)
-  const stream = Readable.from(buffer)
-
-  const mock: Partial<Context> = {
-    request: Object.assign(stream, {
-      url,
-      headers
-    }) as unknown as Context['request'],
-    timing: new Timing(false)
-  }
-
-  return mock as unknown as jest.MockedObject<Context>
-}

package/source/HTTP/messages.ts

@@ -1,110 +0,0 @@
-import { Readable } from 'node:stream'
-import { buffer } from 'node:stream/consumers'
-import { formats } from './formats'
-import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions'
-import type { Context } from './Context'
-import type * as http from 'node:http'
-
-export function write
-(context: Context, response: http.ServerResponse, message: OutgoingMessage): void {
-  for (const transform of context.pipelines.response)
-    transform(message)
-
-  message.headers?.forEach((value, key) => response.setHeader(key, value))
-  context.timing.append(response)
-
-  if (message.body instanceof Readable)
-    stream(message, context, response)
-  else
-    send(message, context, response)
-}
-
-export async function read (context: Context): Promise<any> {
-  const type = context.request.headers['content-type']
-
-  if (type === undefined)
-    return undefined
-
-  if (!(type in formats))
-    throw new UnsupportedMediaType()
-
-  const format = formats[type]
-  const buf = await context.timing.capture('buffer', buffer(context.request))
-
-  try {
-    return format.decode(buf)
-  } catch {
-    throw new BadRequest()
-  }
-}
-
-function send
-(message: OutgoingMessage, context: Context, response: http.ServerResponse): void {
-  if (message.body === undefined || message.body === null) {
-    response.end()
-
-    return
-  }
-
-  if (context.encoder === null)
-    throw new NotAcceptable()
-
-  const buf = context.encoder.encode(message.body)
-
-  response
-    .setHeader('content-type', context.encoder.type)
-    .appendHeader('vary', 'accept')
-    .end(buf)
-}
-
-function stream
-(message: OutgoingMessage, context: Context, response: http.ServerResponse): void {
-  const encoded = message.headers !== undefined && message.headers.has('content-type')
-
-  if (encoded)
-    message.body.pipe(response)
-  else
-    multipart(message, context, response)
-
-  message.body.on('error', (e: Error) => {
-    console.error(e)
-    response.end()
-  })
-}
-
-function multipart
-(message: OutgoingMessage, context: Context, response: http.ServerResponse): void {
-  if (context.encoder === null)
-    throw new NotAcceptable()
-
-  const encoder = context.encoder
-
-  response.setHeader('content-type', `${encoder.multipart}; boundary=${BOUNDARY}`)
-
-  message.body
-    .map((part: unknown) => Buffer.concat([CUT, encoder.encode(part), CRLF]))
-    .on('end', () => response.end(FINALCUT))
-    .pipe(response)
-}
-
-const BOUNDARY = 'cut'
-const CUT = Buffer.from(`--${BOUNDARY}\r\n`)
-const CRLF = Buffer.from('\r\n')
-const FINALCUT = Buffer.from(`--${BOUNDARY}--`)
-
-export interface OutgoingMessage {
-  status?: number
-  headers?: Headers
-  body?: any
-}
-
-export interface Query {
-  [key: string]: string | number | undefined
-
-  id?: string
-  criteria?: string
-  sort?: string
-  omit?: string
-  limit?: string
-  version?: number
-}

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,55 +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 {
-    const request: core.Request = {}
-
-    if (input === undefined && parameters.length > 0)
-      input = {}
-
-    if (typeof input === 'object' && input !== null)
-      for (const parameter of parameters)
-        input[parameter.name] = parameter.value
-
-    if (input !== undefined)
-      request.input = input
-
-    return request
-  }
-}

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('(bar==2;baz==3);(foo==1);(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)
-})