@pikku/core 0.12.4 → 0.12.5

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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,13 @@
+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()