@pikku/core 0.12.4 → 0.12.5

package/src/wirings/http/routers/path-to-regex.test.ts

@@ -0,0 +1,319 @@
+import { test, describe, beforeEach } from 'node:test'
+import * as assert from 'node:assert/strict'
+import { PathToRegexRouter } from './path-to-regex.js'
+import { resetPikkuState, pikkuState } from '../../../pikku-state.js'
+import type { HTTPMethod } from '../http.types.js'
+
+describe('PathToRegexRouter', () => {
+  let router: PathToRegexRouter
+
+  // Helper to create mock route wiring
+  const mockRoute = (route: string) => ({
+    route,
+    method: 'get' as HTTPMethod,
+    func: (() => {}) as any,
+  })
+
+  beforeEach(() => {
+    resetPikkuState()
+    router = new PathToRegexRouter()
+  })
+
+  describe('Static Route Optimization', () => {
+    test('should correctly identify static routes', () => {
+      // Setup test routes
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['/static', mockRoute('/static')],
+              ['/api/about', mockRoute('/api/about')],
+              ['/health', mockRoute('/health')],
+            ]),
+          ],
+        ])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      // Test static routes - should return exact matches with empty params
+      const staticResult = router.match('get', '/static')
+      assert.ok(staticResult, 'Static route should match')
+      assert.strictEqual(staticResult.route, '/static')
+      assert.deepStrictEqual(staticResult.params, {})
+
+      const aboutResult = router.match('get', '/api/about')
+      assert.ok(aboutResult, 'Static route /api/about should match')
+      assert.strictEqual(aboutResult.route, '/api/about')
+      assert.deepStrictEqual(aboutResult.params, {})
+    })
+
+    test('should handle dynamic routes with parameters', () => {
+      // Setup test routes with parameters
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['/api/users/:id', mockRoute('/api/users/:id')],
+              [
+                '/posts/:slug/comments/:commentId',
+                mockRoute('/posts/:slug/comments/:commentId'),
+              ],
+            ]),
+          ],
+        ])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      // Test dynamic routes - should return matches with extracted parameters
+      const userResult = router.match('get', '/api/users/123')
+      assert.ok(userResult, 'Dynamic route should match')
+      assert.strictEqual(userResult.route, '/api/users/:id')
+      assert.strictEqual(userResult.params.id, '123')
+
+      const commentResult = router.match(
+        'get',
+        '/posts/hello-world/comments/456'
+      )
+      assert.ok(commentResult, 'Complex dynamic route should match')
+      assert.strictEqual(
+        commentResult.route,
+        '/posts/:slug/comments/:commentId'
+      )
+      assert.strictEqual(commentResult.params.slug, 'hello-world')
+      assert.strictEqual(commentResult.params.commentId, '456')
+    })
+
+    test('should handle multi-parameter routes', () => {
+      // Setup routes with multiple parameters
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              [
+                '/api/:version/users/:userId',
+                mockRoute('/api/:version/users/:userId'),
+              ],
+              [
+                '/blog/:year/:month/:slug',
+                mockRoute('/blog/:year/:month/:slug'),
+              ],
+            ]),
+          ],
+        ])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      // Test multi-parameter routes
+      const apiResult = router.match('get', '/api/v2/users/456')
+      assert.ok(apiResult, 'Multi-parameter route should match')
+      assert.strictEqual(apiResult.route, '/api/:version/users/:userId')
+      assert.strictEqual(apiResult.params.version, 'v2')
+      assert.strictEqual(apiResult.params.userId, '456')
+
+      const blogResult = router.match('get', '/blog/2024/03/hello-world')
+      assert.ok(blogResult, 'Deep multi-parameter route should match')
+      assert.strictEqual(blogResult.route, '/blog/:year/:month/:slug')
+      assert.strictEqual(blogResult.params.year, '2024')
+      assert.strictEqual(blogResult.params.month, '03')
+      assert.strictEqual(blogResult.params.slug, 'hello-world')
+    })
+
+    test('should prioritize static routes over dynamic routes for performance', () => {
+      // Setup mixed routes where static could conflict with dynamic
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['/api/users', mockRoute('/api/users')], // static
+              ['/api/:resource', mockRoute('/api/:resource')], // dynamic that could match above
+            ]),
+          ],
+        ])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      // Static route should be found first (O(1) lookup)
+      const result = router.match('get', '/api/users')
+      assert.ok(result, 'Route should match')
+      assert.strictEqual(result.route, '/api/users') // Should match static, not dynamic
+      assert.deepStrictEqual(result.params, {})
+    })
+  })
+
+  describe('Path Normalization', () => {
+    test('should normalize paths without leading slash', () => {
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['test', mockRoute('test')], // route without leading slash
+              ['api/health', mockRoute('api/health')],
+            ]),
+          ],
+        ])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      // Should match with or without leading slash in request
+      const result1 = router.match('get', '/test')
+      assert.ok(result1, 'Should match /test')
+      assert.strictEqual(result1.route, 'test')
+
+      const result2 = router.match('get', 'test')
+      assert.ok(result2, 'Should match test')
+      assert.strictEqual(result2.route, 'test')
+
+      const result3 = router.match('get', '/api/health')
+      assert.ok(result3, 'Should match /api/health')
+      assert.strictEqual(result3.route, 'api/health')
+    })
+  })
+
+  describe('Channel Routes Integration', () => {
+    test('should handle channel routes as GET routes', () => {
+      pikkuState(null, 'http', 'routes', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(
+        null,
+        'channel',
+        'channels',
+        new Map([
+          ['websocket-test', { name: 'websocket-test', route: '/ws/test' }],
+          ['chat', { name: 'chat', route: '/chat/:room' }],
+        ])
+      )
+
+      router.initialize()
+
+      // Channel routes should be accessible via GET method
+      const wsResult = router.match('get', '/ws/test')
+      assert.ok(wsResult, 'Static channel route should match')
+      assert.strictEqual(wsResult.route, '/ws/test')
+      assert.deepStrictEqual(wsResult.params, {})
+
+      const chatResult = router.match('get', '/chat/general')
+      assert.ok(chatResult, 'Dynamic channel route should match')
+      assert.strictEqual(chatResult.route, '/chat/:room')
+      assert.strictEqual(chatResult.params.room, 'general')
+    })
+  })
+
+  describe('Middleware Integration', () => {
+    test('should match route without returning middleware', () => {
+      const globalMiddleware = [async () => {}]
+      const routeMiddleware = [async () => {}]
+
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([['get', new Map([['/api/test', mockRoute('/api/test')]])]])
+      )
+      pikkuState(
+        null,
+        'http',
+        'middleware',
+        new Map([
+          ['*', globalMiddleware],
+          ['/api/test', routeMiddleware],
+        ])
+      )
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      const result = router.match('get', '/api/test')
+      assert.ok(result, 'Route should match')
+      // Router only returns route and params, middleware is handled separately
+      assert.strictEqual(result.route, '/api/test')
+      assert.deepStrictEqual(result.params, {})
+    })
+  })
+
+  describe('No Match Scenarios', () => {
+    test('should return null for non-existent routes', () => {
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([['get', new Map([['/existing', mockRoute('/existing')]])]])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      const result = router.match('get', '/non-existent')
+      assert.strictEqual(result, null)
+    })
+
+    test('should return null for unsupported HTTP methods', () => {
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([['get', new Map([['/test', mockRoute('/test')]])]])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      router.initialize()
+
+      const result = router.match('post', '/test')
+      assert.strictEqual(result, null)
+    })
+  })
+
+  describe('Lazy Initialization', () => {
+    test('should initialize automatically on first match call', () => {
+      pikkuState(
+        null,
+        'http',
+        'routes',
+        new Map([['get', new Map([['/test', mockRoute('/test')]])]])
+      )
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
+
+      // Don't call initialize manually
+      const result = router.match('get', '/test')
+      assert.ok(result, 'Should auto-initialize and match')
+      assert.strictEqual(result.route, '/test')
+    })
+  })
+})

package/src/wirings/http/routers/path-to-regex.ts

@@ -0,0 +1,126 @@
+import type { MatchFunction } from 'path-to-regexp'
+import { match } from 'path-to-regexp'
+import type { MatchResult, Router } from './http-router.js'
+import type { HTTPMethod } from '../http.types.js'
+import { pikkuState } from '../../../pikku-state.js'
+
+interface CompiledRoute {
+  matcher: MatchFunction<Partial<Record<string, string | string[]>>>
+  route: string
+}
+
+interface StaticRoute {
+  route: string
+}
+
+export class PathToRegexRouter implements Router {
+  private compiledRoutes: Map<HTTPMethod, Map<string, CompiledRoute>> =
+    new Map()
+  private staticRoutes: Map<HTTPMethod, Map<string, StaticRoute>> = new Map()
+  private isInitialized = false
+
+  public reset() {
+    this.compiledRoutes = new Map()
+    this.staticRoutes = new Map()
+    this.isInitialized = false
+  }
+
+  public initialize() {
+    const routes = pikkuState(null, 'http', 'routes')
+    const channelRoutes = pikkuState(null, 'channel', 'channels')
+
+    // Helper function to compile routes for a given method
+    const compileRoutesForMethod = (
+      method: HTTPMethod,
+      routeEntries: Iterable<[string, any]>
+    ) => {
+      const methodCompiledRoutes =
+        this.compiledRoutes.get(method) || new Map<string, CompiledRoute>()
+      const methodStaticRoutes =
+        this.staticRoutes.get(method) || new Map<string, StaticRoute>()
+
+      for (const [routePath] of routeEntries) {
+        // Normalize route path - ensure it starts with /
+        const normalizedRoutePath = routePath.startsWith('/')
+          ? routePath
+          : `/${routePath}`
+
+        // Check if route is static (no parameters or wildcards)
+        const isStaticRoute = !/\*|:/.test(normalizedRoutePath)
+
+        if (isStaticRoute) {
+          // Store static routes for O(1) lookup
+          methodStaticRoutes.set(normalizedRoutePath, {
+            route: routePath, // Keep the original route path for lookup in pikkuState
+          })
+        } else {
+          // Compile dynamic routes with path-to-regexp
+          const matcher = match(normalizedRoutePath, {
+            decode: decodeURIComponent,
+          })
+
+          methodCompiledRoutes.set(normalizedRoutePath, {
+            matcher,
+            route: routePath, // Keep the original route path for lookup in pikkuState
+          })
+        }
+      }
+
+      this.compiledRoutes.set(method, methodCompiledRoutes)
+      this.staticRoutes.set(method, methodStaticRoutes)
+    }
+
+    // Precompile all HTTP route matchers
+    for (const [method, routeMap] of routes.entries()) {
+      compileRoutesForMethod(method, routeMap.entries())
+    }
+
+    // Precompile all channel route matchers (treating them as GET routes for WebSocket upgrades)
+    const channelRoutesArray: Array<[string, any]> = Array.from(
+      channelRoutes.entries()
+    ).map(([, channel]) => [channel.route, channel])
+    compileRoutesForMethod('get', channelRoutesArray)
+
+    this.isInitialized = true
+  }
+
+  match(method: HTTPMethod, path: string): MatchResult {
+    if (!this.isInitialized) {
+      this.initialize()
+    }
+
+    // Normalize path - ensure it starts with /
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`
+
+    // First, try static routes for O(1) lookup
+    const methodStaticRoutes = this.staticRoutes.get(method)
+    if (methodStaticRoutes) {
+      const staticRoute = methodStaticRoutes.get(normalizedPath)
+      if (staticRoute) {
+        return {
+          route: staticRoute.route,
+          params: {},
+        }
+      }
+    }
+
+    // If no static route matched, try dynamic routes
+    const methodRoutes = this.compiledRoutes.get(method)
+    if (!methodRoutes) {
+      return null
+    }
+
+    // Try each compiled route for this method
+    for (const [, compiledRoute] of methodRoutes.entries()) {
+      const result = compiledRoute.matcher(normalizedPath)
+      if (result) {
+        return {
+          route: compiledRoute.route,
+          params: result.params,
+        }
+      }
+    }
+
+    return null
+  }
+}

package/src/wirings/http/web-request.test.ts

@@ -0,0 +1,236 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import { toWebRequest, applyWebResponse } from './web-request.js'
+import type {
+  PikkuHTTPRequest,
+  PikkuHTTPResponse,
+  PikkuQuery,
+} from './http.types.js'
+
+const createMockRequest = (
+  overrides: Partial<{
+    method: string
+    path: string
+    headers: Record<string, string>
+    query: Record<string, string>
+    body: ArrayBuffer
+  }> = {}
+): PikkuHTTPRequest => ({
+  method: () => (overrides.method ?? 'get') as any,
+  path: () => overrides.path ?? '/test',
+  headers: () => overrides.headers ?? {},
+  header: (name: string) =>
+    (overrides.headers ?? {})[name.toLowerCase()] ?? null,
+  cookie: () => null,
+  params: () => ({}),
+  setParams: () => {},
+  query: () => (overrides.query ?? {}) as PikkuQuery,
+  json: async () => ({}),
+  arrayBuffer: async () => overrides.body ?? new ArrayBuffer(0),
+  data: async () => ({}) as any,
+})
+
+const createMockResponse = () => {
+  const state = {
+    statusCode: 0,
+    headers: {} as Record<string, string | string[]>,
+    body: null as string | null,
+    redirectUrl: null as string | null,
+    redirectStatus: null as number | null,
+  }
+
+  const res: PikkuHTTPResponse = {
+    status(code: number) {
+      state.statusCode = code
+      return res
+    },
+    header(name: string, value: string | string[]) {
+      state.headers[name.toLowerCase()] = value
+      return res
+    },
+    cookie() {
+      return res
+    },
+    json() {
+      return res
+    },
+    arrayBuffer(data: any) {
+      state.body = typeof data === 'string' ? data : null
+      return res
+    },
+    redirect(location: string, status?: number) {
+      state.redirectUrl = location
+      state.redirectStatus = status ?? 302
+      return res
+    },
+  }
+
+  return { res, state }
+}
+
+describe('toWebRequest', () => {
+  test('converts a GET request with correct URL and method', async () => {
+    const req = createMockRequest({
+      method: 'get',
+      path: '/api/test',
+      headers: { host: 'example.com' },
+    })
+
+    const webReq = toWebRequest(req)
+
+    assert.equal(webReq.method, 'GET')
+    assert.equal(new URL(webReq.url).pathname, '/api/test')
+    assert.equal(new URL(webReq.url).host, 'example.com')
+    assert.equal(webReq.body, null)
+  })
+
+  test('copies query parameters', async () => {
+    const req = createMockRequest({
+      query: { search: 'hello', page: '2' },
+    })
+
+    const webReq = toWebRequest(req)
+    const url = new URL(webReq.url)
+
+    assert.equal(url.searchParams.get('search'), 'hello')
+    assert.equal(url.searchParams.get('page'), '2')
+  })
+
+  test('copies all headers', async () => {
+    const req = createMockRequest({
+      headers: {
+        'content-type': 'application/json',
+        authorization: 'Bearer abc123',
+        host: 'localhost',
+      },
+    })
+
+    const webReq = toWebRequest(req)
+
+    assert.equal(webReq.headers.get('content-type'), 'application/json')
+    assert.equal(webReq.headers.get('authorization'), 'Bearer abc123')
+  })
+
+  test('uses custom baseUrl when provided', async () => {
+    const req = createMockRequest({ path: '/callback' })
+
+    const webReq = toWebRequest(req, 'https://myapp.com')
+    const url = new URL(webReq.url)
+
+    assert.equal(url.origin, 'https://myapp.com')
+    assert.equal(url.pathname, '/callback')
+  })
+
+  test('falls back to localhost when no host header', async () => {
+    const req = createMockRequest({ path: '/test' })
+
+    const webReq = toWebRequest(req)
+    const url = new URL(webReq.url)
+
+    assert.equal(url.host, 'localhost')
+  })
+
+  test('POST request includes streaming body', async () => {
+    const bodyContent = JSON.stringify({
+      username: 'admin',
+      password: 'secret',
+    })
+    const encoder = new TextEncoder()
+    const bodyBuffer = encoder.encode(bodyContent).buffer as ArrayBuffer
+
+    const req = createMockRequest({
+      method: 'post',
+      path: '/signin',
+      headers: { 'content-type': 'application/json', host: 'localhost' },
+      body: bodyBuffer,
+    })
+
+    const webReq = toWebRequest(req)
+
+    assert.equal(webReq.method, 'POST')
+    assert.notEqual(webReq.body, null)
+
+    const text = await webReq.text()
+    assert.equal(text, bodyContent)
+  })
+
+  test('GET request has no body', async () => {
+    const req = createMockRequest({ method: 'get' })
+    const webReq = toWebRequest(req)
+    assert.equal(webReq.body, null)
+  })
+
+  test('HEAD request has no body', async () => {
+    const req = createMockRequest({ method: 'head' })
+    const webReq = toWebRequest(req)
+    assert.equal(webReq.body, null)
+  })
+
+  test('OPTIONS request has no body', async () => {
+    const req = createMockRequest({ method: 'options' })
+    const webReq = toWebRequest(req)
+    assert.equal(webReq.body, null)
+  })
+})
+
+describe('applyWebResponse', () => {
+  test('copies status code', async () => {
+    const { res, state } = createMockResponse()
+    const webRes = new Response('OK', { status: 201 })
+
+    await applyWebResponse(res, webRes)
+
+    assert.equal(state.statusCode, 201)
+  })
+
+  test('copies response headers', async () => {
+    const { res, state } = createMockResponse()
+    const webRes = new Response('', {
+      status: 200,
+      headers: {
+        'content-type': 'text/html',
+        'x-custom': 'value',
+      },
+    })
+
+    await applyWebResponse(res, webRes)
+
+    assert.equal(state.headers['content-type'], 'text/html')
+    assert.equal(state.headers['x-custom'], 'value')
+  })
+
+  test('handles redirect via location header', async () => {
+    const { res, state } = createMockResponse()
+    const webRes = new Response(null, {
+      status: 302,
+      headers: { location: 'https://github.com/login/oauth/authorize' },
+    })
+
+    await applyWebResponse(res, webRes)
+
+    assert.equal(state.redirectUrl, 'https://github.com/login/oauth/authorize')
+    assert.equal(state.statusCode, 302)
+  })
+
+  test('writes text body', async () => {
+    const { res, state } = createMockResponse()
+    const webRes = new Response('{"session": true}', {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    })
+
+    await applyWebResponse(res, webRes)
+
+    assert.equal(state.body, '{"session": true}')
+  })
+
+  test('does not write empty body', async () => {
+    const { res, state } = createMockResponse()
+    const webRes = new Response(null, { status: 204 })
+
+    await applyWebResponse(res, webRes)
+
+    assert.equal(state.body, null)
+    assert.equal(state.statusCode, 204)
+  })
+})