@toa.io/extensions.exposition 1.0.0-alpha.292 → 1.0.0-alpha.293

package/source/HTTP/address.test.ts

@@ -1,28 +0,0 @@
-import { it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { address } from './address.js'
-import type { IncomingMessage } from './types.js'
-
-const request = (headers: Record<string, string>): IncomingMessage =>
-  ({ headers, socket: { remoteAddress: '9.9.9.9' } }) as unknown as IncomingMessage
-
-it('should be nothing without a header named', () => {
-  assert.equal(address(request({ 'x-forwarded-for': '1.1.1.1' })), undefined)
-})
-
-it('should be the last value of the named header', () => {
-  assert.equal(
-    address(request({ 'x-forwarded-for': '1.1.1.1, 2.2.2.2' }), 'x-forwarded-for'),
-    '2.2.2.2'
-  )
-  assert.equal(
-    address(request({ 'cf-connecting-ip': '3.3.3.3' }), 'cf-connecting-ip'),
-    '3.3.3.3'
-  )
-})
-
-it('should be nothing when the named header is absent or empty', () => {
-  assert.equal(address(request({}), 'x-real-ip'), undefined)
-  assert.equal(address(request({ 'x-real-ip': ' ' }), 'x-real-ip'), undefined)
-})

package/source/HTTP/address.ts

@@ -1,16 +0,0 @@
-import type { IncomingMessage } from './types.js'
-
-/**
- * The client address: the value of the header the deployment names, and nothing otherwise.
- * Of a header holding a list, the last value is the one the edge in front appended. The
- * connection's address is never it: behind an edge it is the edge's.
- */
-export function address(request: IncomingMessage, header?: string): string | undefined {
-  if (header === undefined) return
-
-  const value = request.headers[header]
-  const raw = Array.isArray(value) ? value[value.length - 1] : value
-  const last = raw?.slice(raw.lastIndexOf(',') + 1).trim()
-
-  return last === '' ? undefined : last
-}

package/source/HTTP/exceptions.ts

@@ -1,99 +0,0 @@
-export class Exception extends Error {
-  public readonly status: number
-  public readonly body?: any
-
-  /** Headers the status is not complete without, like `Retry-After` on a 429. */
-  public readonly headers?: Headers
-
-  protected constructor(status: number, body?: any, headers?: Headers) {
-    super()
-    this.status = status
-    this.body = body
-    this.headers = headers
-  }
-}
-
-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 MethodNotAllowed extends ClientError {
-  public constructor(headers?: Headers) {
-    super(405, undefined, headers)
-  }
-}
-
-export class NotAcceptable extends ClientError {
-  public constructor() {
-    super(406)
-  }
-}
-
-export class Conflict extends ClientError {
-  public constructor(body?: any) {
-    super(409, body)
-  }
-}
-
-export class PreconditionFailed extends ClientError {
-  public constructor() {
-    super(412)
-  }
-}
-
-export class RequestEntityTooLarge extends ClientError {
-  public constructor(body?: any) {
-    super(413, body)
-  }
-}
-
-export class UnsupportedMediaType extends ClientError {
-  public constructor() {
-    super(415)
-  }
-}
-
-export class UnprocessableEntity extends ClientError {
-  public constructor(body?: any) {
-    super(422, body)
-  }
-}
-
-export class TooManyRequests extends ClientError {
-  /** @param retry Seconds until the request would be admitted. */
-  public constructor(retry?: number) {
-    super(
-      429,
-      undefined,
-      retry === undefined ? undefined : new Headers({ 'retry-after': String(retry) })
-    )
-  }
-}
-
-export class ServiceUnavailable extends Exception {
-  public constructor(body?: any) {
-    super(503, body)
-  }
-}

package/source/HTTP/formats/form.ts

@@ -1,21 +0,0 @@
-export const type = 'application/x-www-form-urlencoded'
-
-/**
- * A form is read and never written: it is what an HTML form and a handful of protocols send,
- * and nothing asks for a reply in it.
- *
- * A name repeated in a form is a list, which is how a form says one — `URLSearchParams` keeps
- * every value, and a name given once stays the string it was written as.
- */
-export function decode(buffer: Buffer, charset = 'utf-8'): any {
-  const params = new URLSearchParams(buffer.toString(charset as BufferEncoding))
-  const value: Record<string, string | string[]> = {}
-
-  for (const name of new Set(params.keys())) {
-    const values = params.getAll(name)
-
-    value[name] = values.length === 1 ? values[0] : values
-  }
-
-  return value
-}

package/source/HTTP/formats/index.ts

@@ -1,36 +0,0 @@
-import * as json from './json.js'
-import * as yaml from './yaml.js'
-import * as msgpack from './msgpack.js'
-import * as text from './text.js'
-import * as form from './form.js'
-
-/** What a reply may be encoded as, and so what `accept` is negotiated against. */
-export const formats: Record<string, Format> = {
-  [json.type]: json,
-  [yaml.type]: yaml,
-  [text.type]: text,
-  [msgpack.type]: msgpack
-}
-
-export const types = Object.keys(formats)
-
-/**
- * What a request body may arrive as. Everything a reply may be, and a form besides — which
- * is read and never written, so it is not something a reply can be asked for.
- */
-export const decoders: Record<string, Decoder> = {
-  ...formats,
-  [form.type]: form
-}
-
-export interface Decoder {
-  readonly type: string
-
-  decode: (buffer: Buffer, charset?: string) => any
-}
-
-export interface Format extends Decoder {
-  readonly multipart: string
-
-  encode: (value: any) => Buffer
-}

package/source/HTTP/formats/json.ts

@@ -1,14 +0,0 @@
-export const type = 'application/json'
-export const multipart = 'multipart/json'
-
-export function decode(buffer: Buffer, charset = 'utf-8'): any {
-  const text = buffer.toString(charset as BufferEncoding)
-
-  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,14 +0,0 @@
-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,10 +0,0 @@
-export const type = 'text/plain'
-export const multipart = 'multipart/text'
-
-export function decode(buffer: Buffer, charset = 'utf-8'): any {
-  return buffer.toString(charset as BufferEncoding)
-}
-
-export function encode(value: { toString: () => string }): Buffer {
-  return Buffer.from(value.toString())
-}

package/source/HTTP/formats/yaml.test.ts

@@ -1,22 +0,0 @@
-import { it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { encode } from './yaml.js'
-
-it('encodes error values as their public properties', () => {
-  const value = new (class InvalidUsernameError extends Error {
-    public readonly code = 'INVALID_USERNAME'
-    public override readonly message = 'Username is not meeting the requirements'
-  })()
-
-  assert.strictEqual(
-    encode(value).toString(),
-    'code: INVALID_USERNAME\nmessage: Username is not meeting the requirements\n'
-  )
-})
-
-it('writes a value the way its toJSON says', () => {
-  const secret = { unwrap: () => 's3cret', toJSON: () => '<REDACTED>' }
-
-  assert.strictEqual(encode({ a: 1, b: secret }).toString(), 'a: 1\nb: <REDACTED>\n')
-})

package/source/HTTP/formats/yaml.ts

@@ -1,40 +0,0 @@
-import { yaml } from '@toa.io/generic'
-
-export const type = 'application/yaml'
-export const multipart = 'multipart/yaml'
-
-export function decode(buffer: Buffer, charset = 'utf-8'): any {
-  const text = buffer.toString(charset as BufferEncoding)
-
-  return yaml.load(text)
-}
-
-export function encode(value: any): Buffer {
-  const serializable =
-    value instanceof Error ? Object.assign({}, value) : represent(value)
-  const text = yaml.dump(serializable, { lineWidth: -1, noRefs: true })
-
-  return Buffer.from(text)
-}
-
-/** What says how it is to be written — a redacted secret — is written that way, as in JSON. */
-function represent(value: unknown): unknown {
-  if (
-    typeof value !== 'object' ||
-    value === null ||
-    value instanceof Date ||
-    Buffer.isBuffer(value)
-  )
-    return value
-
-  if ('toJSON' in value && typeof value.toJSON === 'function') return value.toJSON()
-
-  if (Array.isArray(value)) return value.map(represent)
-
-  const object = value as Record<string, unknown>
-  const represented: Record<string, unknown> = {}
-
-  for (const key of Object.keys(object)) represented[key] = represent(object[key])
-
-  return represented
-}

package/source/HTTP/index.ts

@@ -1,6 +0,0 @@
-export * from './Server.js'
-export * from './messages.js'
-export * from './exceptions.js'
-export * from './Context.js'
-export * from './types.js'
-export * from './Probe.js'

package/source/HTTP/messages.test.ts

@@ -1,196 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { PassThrough, Readable } from 'node:stream'
-import * as streamConsumers from 'node:stream/consumers'
-import { generate } from 'randomstring'
-import * as msgpack from 'msgpackr'
-import { multipart, read, type OutgoingMessage } from './messages.js'
-import { BadRequest, UnsupportedMediaType } from './exceptions.js'
-import { formats, types } from './formats/index.js'
-import { Timing } from './Timing.js'
-import type * as http from 'node:http'
-import type { Context } from './Context.js'
-
-beforeEach(() => {
-  resetCalls()
-})
-
-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)
-
-    assert.deepStrictEqual(output, 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)
-
-    assert.deepStrictEqual(value, { 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)
-
-    assert.deepStrictEqual(output, 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)
-
-    assert.deepStrictEqual(output, input)
-  })
-
-  it('should parse application/json with charset parameter', async () => {
-    const path = generate()
-    const headers = { 'content-type': 'application/json; charset=utf-8' }
-    const input = { [generate()]: generate() }
-    const json = JSON.stringify(input)
-    const context = createContext(path, headers, json)
-    const output = await read(context)
-
-    assert.deepStrictEqual(output, 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 assert.rejects(read(request), 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 assert.rejects(read(request), BadRequest)
-  })
-
-  it('should parse application/x-www-form-urlencoded', async () => {
-    const headers = { 'content-type': 'application/x-www-form-urlencoded' }
-    const form = 'grant_type=authorization_code&code=SplxlO&scope=a+b'
-    const request = createContext(generate(), headers, form)
-
-    assert.deepStrictEqual(await read(request), {
-      grant_type: 'authorization_code',
-      code: 'SplxlO',
-      scope: 'a b'
-    })
-  })
-
-  it('should read a repeated form name as the list it is', async () => {
-    const headers = { 'content-type': 'application/x-www-form-urlencoded' }
-    const request = createContext(generate(), headers, 'resource=one&resource=two')
-
-    assert.deepStrictEqual(await read(request), { resource: ['one', 'two'] })
-  })
-
-  it('should not offer a form as a reply encoding', () => {
-    assert.ok(
-      !types.includes('application/x-www-form-urlencoded'),
-      'a form is read and never written'
-    )
-  })
-
-  it('should output correct mulitpart format', async () => {
-    const response = new (class extends PassThrough {
-      public readonly headers = new Headers()
-
-      public setHeader(key: string, value: string): this {
-        this.headers.set(key, value)
-
-        return this
-      }
-    })()
-
-    const context = { encoder: formats['text/plain'] } as unknown as Context
-    const message = {
-      body: Readable.from(['Hello', 'New', 'World'])
-    } as unknown as OutgoingMessage
-
-    const framed = multipart(message, context, response as unknown as http.ServerResponse)
-
-    const result = await streamConsumers.text(framed)
-
-    assert.strictEqual(
-      result,
-      [
-        '--cut',
-        '',
-        'ACK',
-        '--cut',
-        '',
-        'Hello',
-        '--cut',
-        '',
-        'New',
-        '--cut',
-        '',
-        'World',
-        '--cut',
-        '',
-        'FIN',
-        '--cut--'
-      ].join('\r\n')
-    )
-  })
-})
-
-export function createContext(
-  url: string,
-  headers: Record<string, string> = {},
-  content: string | Buffer = ''
-): Context {
-  const data = Buffer.isBuffer(content) ? content : Buffer.from(content)
-  const stream = Readable.from(data)
-  let consumed = false
-
-  const mock: Partial<Context> = {
-    request: Object.assign(stream, {
-      url,
-      headers
-    }) as unknown as Context['request'],
-    url: new URL(url, 'https://host.local'),
-    timing: new Timing(),
-    buffer: async () => {
-      if (consumed) throw new Error('Request body already consumed')
-
-      consumed = true
-
-      return data
-    }
-  }
-
-  return mock as unknown as Context
-}
-
-function resetCalls(target = [], seen = new Set()) {
-  if (target === null || typeof target !== 'object' || seen.has(target)) return
-
-  seen.add(target)
-
-  for (const value of Object.values(target))
-    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
-    else resetCalls(value, seen)
-}