@pikku/core 0.12.20 → 0.12.21

package/src/wirings/http/http-runner.test.ts

@@ -2,7 +2,15 @@ import { test, describe, beforeEach, afterEach } from 'node:test'
 import * as assert from 'assert'
 import { NotFoundError } from '../../errors/errors.js'
 import type { JSONValue, CorePikkuMiddleware } from '../../types/core.types.js'
-import { fetch, wireHTTP } from './http-runner.js'
+import {
+  addHTTPMiddleware,
+  addHTTPPermission,
+  createHTTPWire,
+  fetch,
+  fetchData,
+  pikkuFetch,
+  wireHTTP,
+} from './http-runner.js'
 import { pikkuState, resetPikkuState } from '../../pikku-state.js'
 import {
   PikkuMockRequest,
@@ -16,6 +24,62 @@ const sessionMiddleware: CorePikkuMiddleware = async (services, wire, next) => {
   await next()
 }
 
+class TestRequest extends PikkuMockRequest {
+  private _headers: Record<string, string> = {}
+  private _data: unknown = {}
+
+  setHeaders(headers: Record<string, string>) {
+    this._headers = headers
+  }
+
+  setData(data: unknown) {
+    this._data = data
+  }
+
+  headers(): Record<string, string> {
+    return this._headers
+  }
+
+  header(headerName: string): string | null {
+    return this._headers[headerName] ?? null
+  }
+
+  async data() {
+    return this._data
+  }
+}
+
+class TestResponse extends PikkuMockResponse {
+  public headersMap = new Map<string, string | string[]>()
+  public jsonBody: unknown
+  public bufferBody: unknown
+  public mode: 'stream' | null = null
+  public closed = false
+
+  header(name: string, value: string | string[]): this {
+    this.headersMap.set(name, value)
+    return this
+  }
+
+  arrayBuffer(data: XMLHttpRequestBodyInit): this {
+    this.bufferBody = data
+    return this
+  }
+
+  json(data: unknown): this {
+    this.jsonBody = data
+    return this
+  }
+
+  setMode(mode: 'stream') {
+    this.mode = mode
+  }
+
+  close() {
+    this.closed = true
+  }
+}
+
 const setHTTPFunctionMap = (func: any) => {
   pikkuState(null, 'function', 'meta', {
     pikku_func_name: {
@@ -41,6 +105,35 @@ const setHTTPFunctionMap = (func: any) => {
   addFunction('pikku_func_name', { func })
 }
 
+const setRouteMeta = (
+  route: string,
+  method:
+    | 'get'
+    | 'post'
+    | 'put'
+    | 'delete'
+    | 'patch'
+    | 'head'
+    | 'options' = 'get',
+  overrides: Record<string, unknown> = {}
+) => {
+  const meta = pikkuState(null, 'http', 'meta')
+  meta[method][route] = {
+    pikkuFuncId: 'pikku_func_name',
+    route,
+    method,
+    ...overrides,
+  } as any
+  pikkuState(null, 'function', 'meta')['pikku_func_name'] = {
+    pikkuFuncId: 'pikku_func_name',
+    inputSchemaName: null,
+    outputSchemaName: null,
+    sessionless: true,
+    permissions: undefined,
+    middleware: undefined,
+  } as any
+}
+
 describe('fetch', () => {
   let request: any
   let response: any
@@ -142,3 +235,205 @@ describe('fetch', () => {
     )
   })
 })
+
+describe('http-runner helpers', () => {
+  beforeEach(() => {
+    resetPikkuState()
+    httpRouter.reset()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+      },
+    } as any)
+    pikkuState(null, 'package', 'factories', {
+      createWireServices: async () => ({}),
+    } as any)
+  })
+
+  test('addHTTPMiddleware and addHTTPPermission register route groups', () => {
+    const middleware = [sessionMiddleware]
+    const permissions = [async () => true]
+
+    assert.strictEqual(addHTTPMiddleware('/api/*', middleware), middleware)
+    assert.strictEqual(
+      addHTTPPermission('/api/*', permissions as any),
+      permissions
+    )
+    assert.strictEqual(
+      pikkuState(null, 'middleware', 'httpGroup')['/api/*'],
+      middleware
+    )
+    assert.strictEqual(
+      pikkuState(null, 'permissions', 'httpGroup')['/api/*'],
+      permissions
+    )
+  })
+
+  test('createHTTPWire combines request and response when present', () => {
+    const req = new TestRequest('/x', 'get')
+    const res = new TestResponse()
+
+    assert.deepEqual(createHTTPWire(undefined, undefined), undefined)
+    assert.deepEqual(createHTTPWire(req, undefined), { request: req })
+    assert.deepEqual(createHTTPWire(undefined, res), { response: res })
+    assert.deepEqual(createHTTPWire(req, res), { request: req, response: res })
+  })
+
+  test('wireHTTP skips routes without metadata', () => {
+    const warnings: string[] = []
+    const originalWarn = console.warn
+    console.warn = (message: string) => {
+      warnings.push(message)
+    }
+
+    try {
+      wireHTTP({
+        route: '/missing',
+        method: 'get',
+        func: { func: async () => ({ ok: true }) },
+      })
+    } finally {
+      console.warn = originalWarn
+    }
+
+    assert.equal(
+      pikkuState(null, 'http', 'routes').get('get')?.has('/missing') ?? false,
+      false
+    )
+    assert.match(warnings[0] || '', /Skipping HTTP route 'GET \/missing'/)
+  })
+
+  test('wireHTTP registers route functions when metadata exists', () => {
+    setRouteMeta('/registered')
+
+    wireHTTP({
+      route: '/registered',
+      method: 'get',
+      func: { func: async () => ({ ok: true }) },
+    })
+
+    httpRouter.initialize()
+
+    assert.equal(
+      pikkuState(null, 'http', 'routes').get('get')?.has('/registered'),
+      true
+    )
+  })
+
+  test('fetchData handles OPTIONS preflight through global middleware', async () => {
+    const request = new TestRequest('/anything', 'options')
+    const response = new TestResponse()
+    const execution: string[] = []
+
+    addHTTPMiddleware('*', [
+      async (_services, _wire, next) => {
+        execution.push('global')
+        await next?.()
+      },
+    ])
+
+    await fetchData(request, response)
+
+    assert.equal(response.statusCode, 204)
+    assert.equal(response.jsonBody, undefined)
+    assert.deepEqual(execution, ['global'])
+  })
+
+  test('fetchData sets 204 when a route returns undefined', async () => {
+    setRouteMeta('/no-content')
+    addFunction('pikku_func_name', {
+      func: async () => undefined,
+    })
+    wireHTTP({
+      route: '/no-content',
+      method: 'get',
+      auth: false,
+      func: { func: async () => undefined },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/no-content', 'get')
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.statusCode, 204)
+  })
+
+  test('fetchData writes binary responses when returnsJSON is false', async () => {
+    setRouteMeta('/binary')
+    wireHTTP({
+      route: '/binary',
+      method: 'get',
+      auth: false,
+      returnsJSON: false,
+      func: { func: async () => 'raw-body' },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/binary', 'get')
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.bufferBody, 'raw-body')
+    assert.equal(response.jsonBody, undefined)
+  })
+
+  test('fetchData applies native Response results', async () => {
+    setRouteMeta('/native-response')
+    wireHTTP({
+      route: '/native-response',
+      method: 'get',
+      auth: false,
+      func: {
+        func: async () =>
+          new Response('hello', {
+            status: 202,
+            headers: { 'content-type': 'text/plain', 'x-test': 'ok' },
+          }),
+      },
+    })
+    httpRouter.initialize()
+
+    const result = await pikkuFetch(
+      new Request('https://example.com/native-response')
+    )
+
+    const response = result.toResponse()
+    assert.equal(response.status, 202)
+    assert.equal(await response.text(), 'hello')
+    assert.equal(response.headers.get('x-test'), 'ok')
+  })
+
+  test('fetchData configures SSE mode and streams through channel.send', async () => {
+    setRouteMeta('/sse', 'get', { sse: true })
+    wireHTTP({
+      route: '/sse',
+      method: 'get',
+      sse: true,
+      auth: false,
+      func: {
+        func: async (_services, _data, wire) => {
+          await wire.channel.send({ hello: 'world' })
+          wire.channel.close()
+        },
+      },
+    })
+    httpRouter.initialize()
+
+    const request = new TestRequest('/sse', 'get')
+    request.setData({ open: true })
+    const response = new TestResponse()
+
+    await fetchData(request, response)
+
+    assert.equal(response.mode, 'stream')
+    assert.equal(response.headersMap.get('Content-Type'), 'text/event-stream')
+    assert.equal(response.headersMap.get('Cache-Control'), 'no-cache')
+    assert.equal(response.closed, true)
+    assert.equal(response.bufferBody, JSON.stringify({ hello: 'world' }))
+  })
+})

package/src/wirings/http/http-runner.ts

@@ -159,12 +159,10 @@ export const wireHTTP = <
   Out,
   Route extends string,
   PikkuFunction extends CorePikkuFunction<In, Out> = CorePikkuFunction<In, Out>,
-  PikkuFunctionSessionless extends CorePikkuFunctionSessionless<
-    In,
-    Out
-  > = CorePikkuFunctionSessionless<In, Out>,
-  PikkuPermissionGroup extends
-    CorePikkuPermission<In> = CorePikkuPermission<In>,
+  PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out> =
+    CorePikkuFunctionSessionless<In, Out>,
+  PikkuPermissionGroup extends CorePikkuPermission<In> =
+    CorePikkuPermission<In>,
   PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware,
 >(
   httpWiring: CoreHTTPFunctionWiring<
@@ -360,8 +358,10 @@ const executeRoute = async (
     response.setMode('stream')
     response.header('Content-Type', 'text/event-stream')
     response.header('Cache-Control', 'no-cache')
+    let sseState: unknown
+    const channelId = createWeakUID()
     channel = {
-      channelId: requestId,
+      channelId,
       openingData: await data(),
       send: (data: any) => {
         response.arrayBuffer(isSerializable(data) ? JSON.stringify(data) : data)
@@ -374,6 +374,34 @@ const executeRoute = async (
         response.close?.()
       },
       state: 'open',
+      setState: (s) => {
+        sseState = s
+      },
+      getState: () => sseState as any,
+      clearState: () => {
+        sseState = undefined
+      },
+    }
+
+    // Register the SSE channel with the eventHub (if present) so that
+    // eventHub.publish() can deliver messages to SSE subscribers.
+    // The channel handler wraps the SSE channel to match PikkuChannelHandler.
+    if (singletonServices.eventHub?.onChannelOpened) {
+      const channelRef = channel
+      const channelHandler = {
+        getChannel: () => channelRef,
+        send: (data: unknown, isBinary?: boolean) => {
+          if (isBinary) channelRef.sendBinary(data as any)
+          else channelRef.send(data)
+        },
+        sendBinary: (data: any) => channelRef.sendBinary(data),
+      }
+      singletonServices.eventHub.onChannelOpened(channelHandler)
+      const originalClose = channel.close
+      channel.close = () => {
+        singletonServices.eventHub.onChannelClosed(channelId)
+        originalClose()
+      }
     }
   }
 
@@ -387,27 +415,49 @@ const executeRoute = async (
     hasSessionChanged: () => userSession.sessionChanged,
   }
 
-  result = await runPikkuFunc(
-    'http',
-    `${meta.method}:${meta.route}`,
-    meta.pikkuFuncId,
-    {
-      singletonServices,
-      createWireServices,
-      auth: route.auth !== false,
-      data,
-      inheritedMiddleware: meta.middleware,
-      wireMiddleware: route.middleware,
-      inheritedPermissions: meta.permissions,
-      wirePermissions: route.permissions,
-      coerceDataFromSchema: options.coerceDataFromSchema,
-      tags: route.tags,
-      wire,
-      sessionService: userSession,
-      packageName: meta.packageName,
+  try {
+    result = await runPikkuFunc(
+      'http',
+      `${meta.method}:${meta.route}`,
+      meta.pikkuFuncId,
+      {
+        singletonServices,
+        createWireServices,
+        auth: route.auth !== false,
+        data,
+        inheritedMiddleware: meta.middleware,
+        wireMiddleware: route.middleware,
+        inheritedPermissions: meta.permissions,
+        wirePermissions: route.permissions,
+        coerceDataFromSchema: options.coerceDataFromSchema,
+        tags: route.tags,
+        wire,
+        sessionService: userSession,
+        packageName: meta.packageName,
+      }
+    )
+  } catch (e: any) {
+    if (matchedRoute.route.sse) {
+      singletonServices.logger.error(e instanceof Error ? e.message : e)
+      try {
+        const errorResponse = getErrorResponse(e)
+        http?.response?.arrayBuffer(
+          JSON.stringify({
+            type: 'error',
+            errorText: errorResponse?.message ?? 'Internal server error',
+          })
+        )
+        http?.response?.arrayBuffer(JSON.stringify({ type: 'done' }))
+      } catch {}
+      channel?.close()
+      return wireServices ? { result, wireServices } : { result }
     }
-  )
-  if (!matchedRoute.route.sse) {
+    throw e
+  }
+  if (matchedRoute.route.sse) {
+    // Flush headers after middleware has run so CORS/auth headers are included
+    http?.response?.flushHeaders?.()
+  } else {
     if (result instanceof Response) {
       await applyWebResponse(http!.response!, result)
     } else if (result === undefined || result === null) {
@@ -567,36 +617,16 @@ export const fetchData = async <In, Out>(
 
     return result
   } catch (e: any) {
-    if (matchedRoute?.route.sse) {
-      // For SSE routes, send error through the stream since the response is already in stream mode
-      scopedLogger.error(e instanceof Error ? e.message : e)
-      try {
-        const errorResponse = getErrorResponse(e)
-        response.arrayBuffer(
-          JSON.stringify({
-            type: 'error',
-            errorText: errorResponse?.message ?? 'Internal server error',
-          })
-        )
-        response.arrayBuffer(JSON.stringify({ type: 'done' }))
-      } catch (streamErr: any) {
-        scopedLogger.error(
-          `SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`
-        )
-      }
-      response.close?.()
-    } else {
-      handleHTTPError(
-        e,
-        http,
-        requestId,
-        scopedLogger,
-        logWarningsForStatusCodes,
-        respondWith404,
-        bubbleErrors,
-        exposeErrors
-      )
-    }
+    handleHTTPError(
+      e,
+      http,
+      requestId,
+      scopedLogger,
+      logWarningsForStatusCodes,
+      respondWith404,
+      bubbleErrors,
+      exposeErrors
+    )
   } finally {
     // Clean up any session-specific services created during processing
     if (wireServices) {

package/src/wirings/http/http.types.ts

@@ -116,13 +116,8 @@ export type CoreHTTPFunctionWiring<
   In,
   Out,
   R extends string,
-  PikkuFunction extends CorePikkuFunction<
-    In,
-    Out,
-    any,
-    any,
-    any
-  > = CorePikkuFunction<In, Out>,
+  PikkuFunction extends CorePikkuFunction<In, Out, any, any, any> =
+    CorePikkuFunction<In, Out>,
   PikkuFunctionSessionless extends CorePikkuFunctionSessionless<
     In,
     Out,
@@ -130,15 +125,10 @@ export type CoreHTTPFunctionWiring<
     any,
     any
   > = CorePikkuFunctionSessionless<In, Out>,
-  PikkuPermission extends CorePikkuPermission<
-    In,
-    any,
-    any
-  > = CorePikkuPermission<In, any, any>,
-  PikkuMiddleware extends CorePikkuMiddleware<
-    any,
-    any
-  > = CorePikkuMiddleware<any>,
+  PikkuPermission extends CorePikkuPermission<In, any, any> =
+    CorePikkuPermission<In, any, any>,
+  PikkuMiddleware extends CorePikkuMiddleware<any, any> =
+    CorePikkuMiddleware<any>,
 > =
   | (CoreHTTPFunction & {
       route: R
@@ -290,6 +280,7 @@ export interface PikkuHTTPResponse<Out = unknown> {
   redirect(location: string, status?: number): this
   close?: () => void
   setMode?: (mode: 'stream') => void
+  flushHeaders?: () => void
 }
 
 /**
@@ -301,11 +292,8 @@ export type HTTPRouteConfig<
     | CorePikkuFunctionSessionless<any, any, any, any, any> =
     | CorePikkuFunction<any, any, any, any, any>
     | CorePikkuFunctionSessionless<any, any, any, any, any>,
-  PikkuPermission extends CorePikkuPermission<
-    any,
-    any,
-    any
-  > = CorePikkuPermission<any>,
+  PikkuPermission extends CorePikkuPermission<any, any, any> =
+    CorePikkuPermission<any>,
   PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<
     any,
     any
@@ -331,11 +319,8 @@ export type HTTPRouteConfig<
  * Group-level configuration applied to all routes
  */
 export type HTTPRoutesGroupConfig<
-  PikkuPermission extends CorePikkuPermission<
-    any,
-    any,
-    any
-  > = CorePikkuPermission<any>,
+  PikkuPermission extends CorePikkuPermission<any, any, any> =
+    CorePikkuPermission<any>,
   PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<
     any,
     any

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

@@ -8,9 +8,9 @@ import { UnprocessableContentError } from '../../errors/errors.js'
  * @template In - The type of the request body.
  * @group RequestResponse
  */
-export class PikkuFetchHTTPRequest<In = unknown>
-  implements PikkuHTTPRequest<In>
-{
+export class PikkuFetchHTTPRequest<
+  In = unknown,
+> implements PikkuHTTPRequest<In> {
   #cookies: Partial<Record<string, string>> | undefined
   #params: Partial<Record<string, string | string[]>> = {}
   #url: URL
@@ -105,7 +105,11 @@ export class PikkuFetchHTTPRequest<In = unknown>
     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') {
+        if (
+          key === '__proto__' ||
+          key === 'constructor' ||
+          key === 'prototype'
+        ) {
           continue
         }
         if (key in merged && !valuesAreEquivalent(merged[key], value)) {

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

@@ -79,4 +79,45 @@ describe('PikkuFetchHTTPResponse', () => {
     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)
+  })
 })