@pikku/core 0.9.4 → 0.9.6

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

@@ -83,8 +83,8 @@ export type CoreHTTPFunction = {
 /**
  * Represents a http interaction within Pikku, including a request and response.
  */
-export interface PikkuHTTP {
-  request?: PikkuHTTPRequest
+export interface PikkuHTTP<In = unknown> {
+  request?: PikkuHTTPRequest<In>
   response?: PikkuHTTPResponse
 }
 
@@ -208,7 +208,7 @@ export type HTTPWiringMeta = {
   tags?: string[]
   sse?: true
 }
-export type HTTPWiringsMeta = Array<HTTPWiringMeta>
+export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>
 
 export type HTTPFunctionsMeta = Array<{
   name: string
@@ -234,7 +234,7 @@ export interface PikkuHTTPRequest<In = unknown> {
   query(): PikkuQuery
 }
 
-export interface PikkuHTTPResponse {
+export interface PikkuHTTPResponse<Out = unknown> {
   status(code: number): this
   cookie(name: string, value: string | null, options: SerializeOptions): this
   header(name: string, value: string | string[]): this
@@ -248,7 +248,7 @@ export interface PikkuHTTPResponse {
       | URLSearchParams
       | ReadableStream
   ): this
-  json(data: unknown): this
+  json(data: Out): this
   redirect(location: string, status?: number): this
   close?: () => void
   setMode?: (mode: 'stream') => void

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

@@ -57,6 +57,9 @@ export class PikkuFetchHTTPRequest<In = unknown>
    * @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

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

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

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

@@ -0,0 +1,309 @@
+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 { 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(
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['/static', mockRoute('/static')],
+              ['/api/about', mockRoute('/api/about')],
+              ['/health', mockRoute('/health')],
+            ]),
+          ],
+        ])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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, {})
+      assert.strictEqual(staticResult.middleware?.length, 0)
+
+      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(
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['/api/users/:id', mockRoute('/api/users/:id')],
+              [
+                '/posts/:slug/comments/:commentId',
+                mockRoute('/posts/:slug/comments/:commentId'),
+              ],
+            ]),
+          ],
+        ])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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(
+        '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('http', 'middleware', new Map())
+      pikkuState('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(
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['/api/users', mockRoute('/api/users')], // static
+              ['/api/:resource', mockRoute('/api/:resource')], // dynamic that could match above
+            ]),
+          ],
+        ])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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(
+        'http',
+        'routes',
+        new Map([
+          [
+            'get',
+            new Map([
+              ['test', mockRoute('test')], // route without leading slash
+              ['api/health', mockRoute('api/health')],
+            ]),
+          ],
+        ])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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('http', 'routes', new Map())
+      pikkuState('http', 'middleware', new Map())
+      pikkuState(
+        '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 include global and route-specific middleware', () => {
+      const globalMiddleware = [async () => {}]
+      const routeMiddleware = [async () => {}]
+
+      pikkuState(
+        'http',
+        'routes',
+        new Map([['get', new Map([['/api/test', mockRoute('/api/test')]])]])
+      )
+      pikkuState(
+        'http',
+        'middleware',
+        new Map([
+          ['*', globalMiddleware],
+          ['/api/test', routeMiddleware],
+        ])
+      )
+      pikkuState('channel', 'channels', new Map())
+
+      router.initialize()
+
+      const result = router.match('get', '/api/test')
+      assert.ok(result, 'Route should match')
+      assert.strictEqual(result.middleware?.length, 2) // global + route-specific
+      assert.strictEqual(result.middleware?.[0], globalMiddleware[0])
+      assert.strictEqual(result.middleware?.[1], routeMiddleware[0])
+    })
+  })
+
+  describe('No Match Scenarios', () => {
+    test('should return null for non-existent routes', () => {
+      pikkuState(
+        'http',
+        'routes',
+        new Map([['get', new Map([['/existing', mockRoute('/existing')]])]])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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(
+        'http',
+        'routes',
+        new Map([['get', new Map([['/test', mockRoute('/test')]])]])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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(
+        'http',
+        'routes',
+        new Map([['get', new Map([['/test', mockRoute('/test')]])]])
+      )
+      pikkuState('http', 'middleware', new Map())
+      pikkuState('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,162 @@
+import { match, MatchFunction } from 'path-to-regexp'
+import { MatchResult, Router } from './http-router.js'
+import { HTTPMethod } from '../http.types.js'
+import { pikkuState } from '../../../pikku-state.js'
+import { CorePikkuMiddleware } from '../../../types/core.types.js'
+
+interface CompiledRoute {
+  matcher: MatchFunction<Partial<Record<string, string | string[]>>>
+  route: string
+  middleware: CorePikkuMiddleware[]
+}
+
+interface StaticRoute {
+  route: string
+  middleware: CorePikkuMiddleware[]
+}
+
+export class PathToRegexRouter implements Router {
+  private compiledRoutes: Map<HTTPMethod, Map<string, CompiledRoute>> =
+    new Map()
+  private staticRoutes: Map<HTTPMethod, Map<string, StaticRoute>> = new Map()
+  private precompiledMiddleware: Map<string, CorePikkuMiddleware[]> = new Map()
+  private isInitialized = false
+
+  public initialize() {
+    const routes = pikkuState('http', 'routes')
+    const channelRoutes = pikkuState('channel', 'channels')
+    const middlewareMap = pikkuState('http', 'middleware')
+
+    // Precompile middleware lookups
+    for (const [middlewareRoute, middlewareArray] of middlewareMap.entries()) {
+      this.precompiledMiddleware.set(middlewareRoute, middlewareArray)
+    }
+
+    // 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)
+
+        // Precompute middleware for this route
+        const routeMiddleware: CorePikkuMiddleware[] = []
+
+        // Add global middleware (*)
+        const globalMiddleware = this.precompiledMiddleware.get('*')
+        if (globalMiddleware) {
+          routeMiddleware.push(...globalMiddleware)
+        }
+
+        // Add route-specific middleware
+        for (const [
+          middlewareRoute,
+          middlewareArray,
+        ] of this.precompiledMiddleware.entries()) {
+          if (middlewareRoute !== '*') {
+            // Use regex test for pattern matching
+            try {
+              if (new RegExp(middlewareRoute).test(normalizedRoutePath)) {
+                routeMiddleware.push(...middlewareArray)
+              }
+            } catch {
+              // If regex is invalid, do exact match
+              if (middlewareRoute === normalizedRoutePath) {
+                routeMiddleware.push(...middlewareArray)
+              }
+            }
+          }
+        }
+
+        if (isStaticRoute) {
+          // Store static routes for O(1) lookup
+          methodStaticRoutes.set(normalizedRoutePath, {
+            route: routePath, // Keep the original route path for lookup in pikkuState
+            middleware: routeMiddleware,
+          })
+        } 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
+            middleware: routeMiddleware,
+          })
+        }
+      }
+
+      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: {},
+          middleware: staticRoute.middleware,
+        }
+      }
+    }
+
+    // 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,
+          middleware: compiledRoute.middleware,
+        }
+      }
+    }
+
+    return null
+  }
+}

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

@@ -1,8 +1,9 @@
-import type {
-  CoreServices,
-  CoreSingletonServices,
-  CoreUserSession,
-  CreateSessionServices,
+import {
+  PikkuWiringTypes,
+  type CoreServices,
+  type CoreSingletonServices,
+  type CoreUserSession,
+  type CreateSessionServices,
 } from '../../types/core.types.js'
 import type {
   CoreMCPResource,
@@ -20,7 +21,7 @@ import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { rpcService } from '../rpc/rpc-runner.js'
 import { BadRequestError, NotFoundError } from '../../errors/errors.js'
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js'
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
 
 export class MCPError extends Error {
   constructor(public readonly error: JsonRpcErrorResponse) {
@@ -253,19 +254,29 @@ async function runMCPPikkuFunc(
         })
       }
 
-      result = await runPikkuFunc(pikkuFuncName, {
-        getAllServices,
-        session,
-        data: request.params,
-        tags: mcp.tags,
-      })
+      result = await runPikkuFunc(
+        PikkuWiringTypes.mcp,
+        `${type}:${name}`,
+        pikkuFuncName,
+        {
+          getAllServices,
+          session,
+          data: request.params,
+          tags: mcp.tags,
+        }
+      )
     }
 
-    // Get middleware for tags and run middleware
+    const funcConfig = pikkuState('function', 'functions').get(pikkuFuncName!)
     await runMiddleware(
       singletonServices,
       { mcp: interaction },
-      addMiddlewareForTags(mcp.middleware, mcp.tags),
+      combineMiddleware(PikkuWiringTypes.mcp, `${type}:${name}`, {
+        wiringMiddleware: mcp.middleware,
+        wiringTags: mcp.tags,
+        funcMiddleware: funcConfig?.middleware,
+        funcTags: funcConfig?.tags,
+      }),
       runMain
     )
 

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

@@ -4,8 +4,11 @@ import type { CorePikkuFunctionSessionless } from '../../function/functions.type
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { CreateSessionServices } from '../../types/core.types.js'
-import { addMiddlewareForTags, runMiddleware } from '../../middleware-runner.js'
+import {
+  CreateSessionServices,
+  PikkuWiringTypes,
+} from '../../types/core.types.js'
+import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
 
 /**
  * Error class for queue processor not found
@@ -149,22 +152,37 @@ export async function runQueueJob({
       })
 
       // Execute the pikku function with the job data
-      result = await runPikkuFunc(processorMeta.pikkuFuncName, {
-        getAllServices,
-        data: job.data,
-        tags: queueWorker.tags,
-      })
+      result = await runPikkuFunc(
+        PikkuWiringTypes.queue,
+        job.queueName,
+        processorMeta.pikkuFuncName,
+        {
+          getAllServices,
+          data: job.data,
+          tags: queueWorker.tags,
+        }
+      )
 
       logger.debug(
         `Successfully processed job ${job.id} in queue ${job.queueName}`
       )
     }
 
+    // Get function config for middleware and tags
+    const funcConfig = pikkuState('function', 'functions').get(
+      processorMeta.pikkuFuncName
+    )
+
     // Get middleware for tags and combine with queue-specific middleware
     await runMiddleware(
       singletonServices,
       { queue },
-      addMiddlewareForTags(queueWorker.middleware, queueWorker.tags),
+      combineMiddleware(PikkuWiringTypes.queue, `${job.queueName}:${job.id}`, {
+        wiringMiddleware: queueWorker.middleware,
+        wiringTags: queueWorker.tags,
+        funcMiddleware: funcConfig?.middleware,
+        funcTags: funcConfig?.tags,
+      }),
       runMain
     )