@pikku/core 0.12.3 → 0.12.4

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

@@ -1,170 +0,0 @@
-import { parse as parseQuery } from 'picoquery'
-import { parse as parseCookie } from 'cookie'
-import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js'
-import { UnprocessableContentError } from '../../errors/errors.js'
-
-/**
- * Abstract class representing a pikku request.
- * @template In - The type of the request body.
- * @group RequestResponse
- */
-export class PikkuFetchHTTPRequest<In = unknown>
-  implements PikkuHTTPRequest<In>
-{
-  #cookies: Partial<Record<string, string>> | undefined
-  #params: Partial<Record<string, string | string[]>> = {}
-  #url: URL
-
-  constructor(private request: Request) {
-    this.#url = new URL(request.url)
-  }
-
-  public method(): HTTPMethod {
-    return this.request.method.toLowerCase() as HTTPMethod
-  }
-
-  public path(): string {
-    return this.#url.pathname
-  }
-
-  /**
-   * Retrieves the request body.
-   * @returns A promise that resolves to the request body.
-   */
-  public json(): Promise<In> {
-    return this.request.json()
-  }
-
-  /**
-   * Retrieves the raw request body as a Buffer.
-   * @returns A promise that resolves to the raw request body.
-   */
-  public arrayBuffer(): Promise<ArrayBuffer> {
-    return this.request.arrayBuffer()
-  }
-
-  public headers(): Record<string, string> {
-    return Object.fromEntries(this.request.headers.entries())
-  }
-
-  /**
-   * Retrieves the value of a specific header.
-   * @param headerName - The name of the header to retrieve.
-   * @returns The value of the header, or undefined if the header is not found.
-   */
-  public header(headerName: string): string | null {
-    return this.request.headers.get(headerName.toLowerCase())
-  }
-
-  /**
-   * Retrieves the cookies from the request.
-   * @returns An object containing the cookies.
-   */
-  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
-  }
-
-  /**
-   * Retrieves the request parameters.
-   * @returns An object containing the request parameters.
-   */
-  public params(): Partial<Record<string, string | string[]>> {
-    return this.#params
-  }
-
-  /**
-   * Sets the request parameters.
-   * @param params - An object containing the request parameters to set.
-   */
-  public setParams(
-    params: Record<string, string | string[] | undefined>
-  ): void {
-    this.#params = params
-  }
-
-  /**
-   * Retrieves the query parameters from the request.
-   * @returns An object containing the query parameters.
-   */
-  public query(): PikkuQuery {
-    return parseQuery(this.#url.searchParams.toString()) as PikkuQuery
-  }
-
-  /**
-   * Retrieves the combined data from the request, including parameters, query, and body.
-   * @returns A promise that resolves to an object containing the combined data.
-   */
-  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 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 parsed = await this.json()
-        body =
-          typeof parsed === 'object' &&
-          parsed !== null &&
-          !Array.isArray(parsed)
-            ? parsed
-            : { data: parsed }
-      } else if (contentType.includes('text/')) {
-        const text = await this.request.text()
-        body = { data: text }
-      } else if (contentType.includes('application/octet-stream')) {
-        const buffer = await this.request.arrayBuffer()
-        body = { data: buffer }
-      } else if (contentType === 'application/x-www-form-urlencoded') {
-        const text = await this.request.text()
-        body = Object.fromEntries(new URLSearchParams(text))
-      } else {
-        throw new UnprocessableContentError(
-          `Unsupported content type ${contentType}`
-        )
-      }
-    } catch (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): string | number | boolean {
-  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 as any
-}

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

@@ -1,82 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'assert'
-import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js' // Adjust path if needed
-
-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')
-  })
-})

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

@@ -1,147 +0,0 @@
-import type { PikkuHTTPResponse } from './http.types.js'
-import type { SerializeOptions as CookieSerializeOptions } from 'cookie'
-import { serialize as serializeCookie } 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 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 }]) => serializeCookie(name, value, flags)
-    )
-    // Multiple Set-Cookie headers must be appended separately, not joined with commas
-    // per HTTP specification (RFC 6265)
-    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
-
-        // Force initial flush
-        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()