@pikku/core 0.12.106 → 0.12.111

package/src/wirings/http/pikku-fetch-http-request.ts

@@ -1,260 +0,0 @@
-import { parse as parseQuery } from 'picoquery'
-import { parseCookie } from 'cookie'
-import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js'
-import {
-  PayloadTooLargeError,
-  UnprocessableContentError,
-} from '../../errors/errors.js'
-
-export const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024
-
-export type PikkuFetchHTTPRequestOptions = Partial<{
-  /** Maximum request body size in bytes. Defaults to {@link DEFAULT_MAX_BODY_SIZE}. */
-  maxBodySize: number
-}>
-
-/**
- * @group RequestResponse
- */
-export class PikkuFetchHTTPRequest<
-  In = unknown,
-> implements PikkuHTTPRequest<In> {
-  #cookies: Partial<Record<string, string>> | undefined
-  #params: Partial<Record<string, string | string[]>> = {}
-  #url: URL
-  #rawBodyText: string | undefined
-  #rawBodyBuffer: ArrayBuffer | undefined
-  #rawBufferPromise: Promise<ArrayBuffer> | undefined
-  #maxBodySize: number
-
-  constructor(
-    private request: Request,
-    { maxBodySize = DEFAULT_MAX_BODY_SIZE }: PikkuFetchHTTPRequestOptions = {}
-  ) {
-    this.#url = new URL(request.url)
-    this.#maxBodySize = maxBodySize
-  }
-
-  public method(): HTTPMethod {
-    return this.request.method.toLowerCase() as HTTPMethod
-  }
-
-  public path(): string {
-    return this.#url.pathname
-  }
-
-  public async json(): Promise<In> {
-    const text = await this.#readRawText()
-    return JSON.parse(text) as In
-  }
-
-  public async arrayBuffer(): Promise<ArrayBuffer> {
-    return this.#readRawBuffer()
-  }
-
-  async #readRawBuffer(): Promise<ArrayBuffer> {
-    if (this.#rawBodyBuffer !== undefined) {
-      return this.#rawBodyBuffer
-    }
-    if (this.#rawBodyText !== undefined) {
-      const buf = new TextEncoder().encode(this.#rawBodyText)
-        .buffer as ArrayBuffer
-      this.#rawBodyBuffer = buf
-      return buf
-    }
-    if (this.#rawBufferPromise !== undefined) {
-      console.warn(
-        `[pikku] request body for ${this.method().toUpperCase()} ${this.path()} ` +
-          `was requested again before the first read resolved — the read is now ` +
-          `shared, but a duplicate body consumer (e.g. middleware calling ` +
-          `toWebRequest just for headers) should be removed.`
-      )
-      return this.#rawBufferPromise
-    }
-    this.#rawBufferPromise = this.#readBoundedBuffer().then((buf) => {
-      this.#rawBodyBuffer = buf
-      return buf
-    })
-    return this.#rawBufferPromise
-  }
-
-  async #readBoundedBuffer(): Promise<ArrayBuffer> {
-    const contentLength = this.request.headers.get('content-length')
-    if (contentLength !== null) {
-      const declaredSize = Number(contentLength)
-      if (Number.isFinite(declaredSize) && declaredSize > this.#maxBodySize) {
-        throw this.#payloadTooLarge()
-      }
-    }
-
-    const stream = this.request.body
-    if (stream === null) {
-      const buffer = await this.request.arrayBuffer()
-      if (buffer.byteLength > this.#maxBodySize) {
-        throw this.#payloadTooLarge()
-      }
-      return buffer
-    }
-
-    const reader = stream.getReader()
-    const chunks: Uint8Array[] = []
-    let size = 0
-    try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) {
-          break
-        }
-        size += value.byteLength
-        if (size > this.#maxBodySize) {
-          await reader.cancel()
-          throw this.#payloadTooLarge()
-        }
-        chunks.push(value)
-      }
-    } finally {
-      reader.releaseLock()
-    }
-
-    const body = new Uint8Array(size)
-    let offset = 0
-    for (const chunk of chunks) {
-      body.set(chunk, offset)
-      offset += chunk.byteLength
-    }
-    return body.buffer as ArrayBuffer
-  }
-
-  #payloadTooLarge(): PayloadTooLargeError {
-    return new PayloadTooLargeError(
-      `Request body exceeds the maximum size of ${this.#maxBodySize} bytes`
-    )
-  }
-
-  async #readRawText(): Promise<string> {
-    if (this.#rawBodyText !== undefined) {
-      return this.#rawBodyText
-    }
-    const text = new TextDecoder().decode(await this.#readRawBuffer())
-    this.#rawBodyText = text
-    return text
-  }
-
-  public headers(): Record<string, string> {
-    return Object.fromEntries(this.request.headers.entries())
-  }
-
-  public header(headerName: string): string | null {
-    return this.request.headers.get(headerName.toLowerCase())
-  }
-
-  public cookie(cookieName: string): string | null {
-    if (this.#cookies?.[cookieName]) {
-      return this.#cookies[cookieName]
-    }
-    const cookieHeader = this.header('cookie')
-    this.#cookies = cookieHeader ? parseCookie(cookieHeader) : {}
-    return this.#cookies[cookieName] || null
-  }
-
-  public params(): Partial<Record<string, string | string[]>> {
-    return this.#params
-  }
-
-  public setParams(
-    params: Record<string, string | string[] | undefined>
-  ): void {
-    this.#params = params
-  }
-
-  public query(): PikkuQuery {
-    return parseQuery(this.#url.searchParams.toString()) as PikkuQuery
-  }
-
-  public async data(): Promise<In> {
-    const body = await this.body()
-    const parts = [this.params(), this.query(), body]
-    const merged: Record<string, unknown> = {}
-    for (const part of parts) {
-      for (const [key, value] of Object.entries(part)) {
-        if (
-          key === '__proto__' ||
-          key === 'constructor' ||
-          key === 'prototype'
-        ) {
-          continue
-        }
-        if (key in merged && !valuesAreEquivalent(merged[key], value)) {
-          throw new UnprocessableContentError(
-            `Conflicting values for key "${key}": "${merged[key]}" vs "${value}"`
-          )
-        }
-        merged[key] ??= value
-      }
-    }
-    return merged as In
-  }
-
-  private async body(): Promise<any> {
-    const noBodyMethods: HTTPMethod[] = ['get', 'head', 'options', 'delete']
-    if (noBodyMethods.includes(this.method())) {
-      return {}
-    }
-
-    let body: any = {}
-    const contentType = this.header('content-type') || ''
-    try {
-      if (contentType.includes('application/json')) {
-        const text = await this.#readRawText()
-        const parsed = text ? JSON.parse(text) : null
-        body =
-          typeof parsed === 'object' &&
-          parsed !== null &&
-          !Array.isArray(parsed)
-            ? parsed
-            : { data: parsed }
-      } else if (contentType.includes('text/')) {
-        const text = await this.#readRawText()
-        body = { data: text }
-      } else if (contentType.includes('application/octet-stream')) {
-        const buffer = await this.arrayBuffer()
-        body = { data: buffer }
-      } else if (contentType === 'application/x-www-form-urlencoded') {
-        const text = await this.#readRawText()
-        const params = new URLSearchParams(text)
-        let count = 0
-        for (const _ of params) {
-          if (++count > 256) {
-            throw new UnprocessableContentError('Too many form parameters')
-          }
-        }
-        body = Object.fromEntries(params)
-      } else {
-        throw new UnprocessableContentError(
-          `Unsupported content type ${contentType}`
-        )
-      }
-    } catch (e) {
-      if (e instanceof PayloadTooLargeError) {
-        throw e
-      }
-      throw new UnprocessableContentError(`Error parsing body: ${e}`)
-    }
-    return body
-  }
-}
-
-function valuesAreEquivalent(a: unknown, b: unknown): boolean {
-  return coerce(a) === coerce(b)
-}
-
-function coerce(value: unknown): unknown {
-  if (typeof value === 'boolean' || typeof value === 'number') return value
-  if (typeof value === 'string') {
-    if (value === 'true') return true
-    if (value === 'false') return false
-    const num = Number(value)
-    return isNaN(num) ? value : num
-  }
-  return value
-}

package/src/wirings/http/pikku-fetch-http-response.test.ts

@@ -1,123 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'assert'
-import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
-
-describe('PikkuFetchHTTPResponse', () => {
-  test('sets status code', () => {
-    const res = new PikkuFetchHTTPResponse().status(404).toResponse()
-    assert.strictEqual(res.status, 404)
-  })
-
-  test('sets headers', async () => {
-    const res = new PikkuFetchHTTPResponse()
-      .header('X-Test', 'value')
-      .header('X-Multi', ['a', 'b'])
-      .toResponse()
-
-    assert.strictEqual(res.headers.get('X-Test'), 'value')
-    const multi = res.headers.get('X-Multi')?.split(', ')
-    assert.deepEqual(multi, ['a', 'b'])
-  })
-
-  test('sets cookies', () => {
-    const res = new PikkuFetchHTTPResponse()
-      .cookie('token', 'abc123', { httpOnly: true, path: '/' })
-      .cookie('other', 'val', { maxAge: 3600 })
-      .toResponse()
-
-    const setCookieHeader = res.headers.get('Set-Cookie')
-    assert.ok(setCookieHeader)
-
-    const cookies = setCookieHeader!.split(', ')
-    assert.ok(cookies.some((c) => c.startsWith('token=abc123')))
-    assert.ok(cookies.some((c) => c.startsWith('other=val')))
-  })
-
-  test('json sets correct content type and body', async () => {
-    const res = new PikkuFetchHTTPResponse()
-      .json({ hello: 'world' })
-      .toResponse()
-
-    assert.strictEqual(res.headers.get('Content-Type'), 'application/json')
-    const body = await res.json()
-    assert.deepEqual(body, { hello: 'world' })
-  })
-
-  test('text sets correct content type and body', async () => {
-    const res = new PikkuFetchHTTPResponse().text('hello').toResponse()
-
-    assert.strictEqual(res.headers.get('Content-Type'), 'text/plain')
-    const text = await res.text()
-    assert.strictEqual(text, 'hello')
-  })
-
-  test('html sets correct content type and body', async () => {
-    const res = new PikkuFetchHTTPResponse().html('<p>hi</p>').toResponse()
-
-    assert.strictEqual(res.headers.get('Content-Type'), 'text/html')
-    const text = await res.text()
-    assert.strictEqual(text, '<p>hi</p>')
-  })
-
-  test('arrayBuffer sets correct content type', async () => {
-    const buffer = new Uint8Array([1, 2, 3]).buffer
-    const res = new PikkuFetchHTTPResponse().arrayBuffer(buffer).toResponse()
-
-    assert.strictEqual(
-      res.headers.get('Content-Type'),
-      'application/octet-stream'
-    )
-    const body = await res.arrayBuffer()
-    assert.deepEqual(new Uint8Array(body), new Uint8Array([1, 2, 3]))
-  })
-
-  test('redirect sets Location header and status', () => {
-    const res = new PikkuFetchHTTPResponse()
-      .redirect('/login', 301)
-      .toResponse()
-
-    assert.strictEqual(res.status, 301)
-    assert.strictEqual(res.headers.get('Location'), '/login')
-  })
-
-  test('redirect rejects invalid redirect locations', () => {
-    assert.throws(
-      () => new PikkuFetchHTTPResponse().redirect('login'),
-      /Invalid redirect location/
-    )
-  })
-
-  test('send stores raw body content', async () => {
-    const res = new PikkuFetchHTTPResponse().send('plain-body').toResponse()
-
-    assert.strictEqual(await res.text(), 'plain-body')
-  })
-
-  test('stream mode writes json/text/html/arrayBuffer and close completes the stream', async () => {
-    const res = new PikkuFetchHTTPResponse()
-    res.setMode('stream')
-    res.json({ hello: 'world' })
-    res.text('plain')
-    res.html('<p>html</p>')
-    res.arrayBuffer('bytes')
-    res.close()
-
-    const response = res.toResponse()
-    const text = await response.text()
-
-    assert.ok(text.startsWith(':\n\n'))
-    assert.ok(text.includes('data: {"hello":"world"}\n\n'))
-    assert.ok(text.includes('data: plain\n\n'))
-    assert.ok(text.includes('data: <p>html</p>\n\n'))
-    assert.ok(text.includes('data: bytes\n\n'))
-  })
-
-  test('toResponse preserves the instance status over response init args', () => {
-    const res = new PikkuFetchHTTPResponse()
-      .status(201)
-      .json({ ok: true })
-      .toResponse({ status: 202 })
-
-    assert.strictEqual(res.status, 201)
-  })
-})

package/src/wirings/http/pikku-fetch-http-response.ts

@@ -1,149 +0,0 @@
-import type { PikkuHTTPResponse } from './http.types.js'
-import type { SerializeOptions as CookieSerializeOptions } from 'cookie'
-import { stringifySetCookie } from 'cookie'
-
-export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
-  #statusCode: number = 200
-  #headers = new Headers()
-  #cookies = new Map<string, { value: string; flags: CookieSerializeOptions }>()
-
-  #body: BodyInit | null = null
-  #responseMode: 'stream' | null = null
-  #send: ((data: string) => void) | null = null
-  #close: (() => void) | null = null
-
-  public setMode(mode: 'stream') {
-    this.#responseMode = 'stream'
-    if (mode === 'stream') {
-      this.#body = this.createStream()
-    }
-  }
-
-  public get statusCode(): number {
-    return this.#statusCode
-  }
-
-  public status(code: number): this {
-    this.#statusCode = code
-    return this
-  }
-
-  public cookie(
-    name: string,
-    value: string,
-    flags: CookieSerializeOptions
-  ): this {
-    this.#cookies.set(name, { value, flags })
-    return this
-  }
-
-  public header(name: string, value: string | string[]): this {
-    this.#headers.delete(name)
-    if (Array.isArray(value)) {
-      value.forEach((v) => this.#headers.append(name, v))
-    } else {
-      this.#headers.set(name, value)
-    }
-    return this
-  }
-
-  public arrayBuffer(data: XMLHttpRequestBodyInit): this {
-    if (this.#responseMode === 'stream') {
-      this.#send!(data as string)
-    } else {
-      this.#body = data
-      this.header('Content-Type', 'application/octet-stream')
-    }
-    return this
-  }
-
-  public json(data: unknown): this {
-    if (this.#responseMode === 'stream') {
-      this.#send!(JSON.stringify(data))
-    } else {
-      this.#body = JSON.stringify(data)
-      this.header('Content-Type', 'application/json')
-    }
-    return this
-  }
-
-  public text(content: string): this {
-    if (this.#responseMode === 'stream') {
-      this.#send!(content)
-    } else {
-      this.#body = content
-      this.header('Content-Type', 'text/plain')
-    }
-    return this
-  }
-
-  public html(content: string): this {
-    if (this.#responseMode === 'stream') {
-      this.#send!(content)
-    } else {
-      this.#body = content
-      this.header('Content-Type', 'text/html')
-    }
-    return this
-  }
-
-  public send(data: any): this {
-    this.#body = data
-    return this
-  }
-
-  public redirect(location: string, status: number = 302): this {
-    if (
-      !location.startsWith('/') &&
-      !location.startsWith('https://') &&
-      !location.startsWith('http://')
-    ) {
-      throw new Error(
-        'Invalid redirect location: must be a relative path or absolute URL'
-      )
-    }
-    this.#statusCode = status
-    this.header('Location', location)
-    return this
-  }
-
-  public close(): this {
-    if (this.#close) {
-      this.#close()
-    }
-    return this
-  }
-
-  public toResponse(args?: Record<string, any>): Response {
-    const cookieHeader = Array.from(this.#cookies.entries()).map(
-      ([name, { value, flags }]) =>
-        stringifySetCookie({ name, value, ...flags }, flags)
-    )
-    cookieHeader.forEach((cookie) => this.#headers.append('Set-Cookie', cookie))
-    return new Response(this.#body, {
-      ...args,
-      status: this.#statusCode,
-      headers: this.#headers,
-    })
-  }
-
-  private createStream(): ReadableStream<Uint8Array> {
-    const encoder = new TextEncoder()
-    return new ReadableStream({
-      start: (controller) => {
-        const send = (data: string) => {
-          controller.enqueue(encoder.encode(`data: ${data}\n\n`))
-        }
-
-        const close = () => {
-          controller.close()
-        }
-
-        this.#send = send
-        this.#close = close
-
-        controller.enqueue(encoder.encode(':\n\n'))
-      },
-    })
-  }
-}

package/src/wirings/http/routers/http-router.ts

@@ -1,13 +0,0 @@
-import type { HTTPMethod } from '../http.types.js'
-import { PathToRegexRouter } from './path-to-regex.js'
-
-export type MatchResult = {
-  route: string
-  params: Record<string, any>
-} | null
-
-export interface Router {
-  match(method: HTTPMethod, path: string): MatchResult
-}
-
-export const httpRouter = new PathToRegexRouter()