@pikku/core 0.9.5 → 0.9.6

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

@@ -12,8 +12,8 @@ import {
   CoreUserSession,
   CorePikkuMiddleware,
   SessionServices,
+  PikkuWiringTypes,
 } from '../../types/core.types.js'
-import { match } from 'path-to-regexp'
 import { MissingSessionError, NotFoundError } from '../../errors/errors.js'
 import {
   closeSessionServices,
@@ -32,6 +32,7 @@ import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js'
 import { PikkuChannel } from '../channel/channel.types.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { rpcService } from '../rpc/rpc-runner.js'
+import { httpRouter } from './routers/http-router.js'
 
 /**
  * Registers middleware either globally or for a specific route.
@@ -49,32 +50,20 @@ export const addHTTPMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   middleware?: PikkuMiddleware[]
 ) => {
   const middlewareStore = pikkuState('http', 'middleware')
+  let route = '*'
 
-  if (typeof routeOrMiddleware === 'string' && middleware) {
-    const route = routeOrMiddleware
-
-    // Remove existing entry for this route if it exists
-    const existingIndex = middlewareStore.findIndex(
-      (item) => item.route === route
-    )
-    if (existingIndex !== -1) {
-      middlewareStore.splice(existingIndex, 1)
-    }
-
-    middlewareStore.push({ route, middleware })
+  if (typeof routeOrMiddleware === 'string') {
+    route = routeOrMiddleware
+    middleware = middleware!
   } else {
-    // Handle global middleware
-    const existingIndex = middlewareStore.findIndex(
-      (item) => item.route === '*'
-    )
-    if (existingIndex !== -1) {
-      middlewareStore.splice(existingIndex, 1)
-    }
+    middleware = routeOrMiddleware
+  }
 
-    middlewareStore.push({
-      route: '*',
-      middleware: routeOrMiddleware as any,
-    })
+  const currentMiddleware = middlewareStore.get(route)
+  if (currentMiddleware) {
+    middlewareStore.set(route, [...currentMiddleware, ...middleware])
+  } else {
+    middlewareStore.set(route, middleware)
   }
 }
 
@@ -113,10 +102,7 @@ export const wireHTTP = <
   >
 ) => {
   const httpMeta = pikkuState('http', 'meta')
-  const routeMeta = httpMeta.find(
-    (meta) =>
-      meta.route === httpWiring.route && meta.method === httpWiring.method
-  )
+  const routeMeta = httpMeta[httpWiring.method][httpWiring.route]
   if (!routeMeta) {
     throw new Error('Route metadata not found')
   }
@@ -142,43 +128,29 @@ export const wireHTTP = <
  * @returns {Object | undefined} An object with matched route details or undefined if no match.
  */
 const getMatchingRoute = (requestType: string, requestPath: string) => {
-  const allRoutes = pikkuState('http', 'routes')
-  const middleware = pikkuState('http', 'middleware')
-  const routes = allRoutes.get(requestType.toLowerCase() as HTTPMethod)
-  if (!routes) {
-    return undefined
-  }
-  for (const route of routes.values()) {
-    // Generate a matching function from the route pattern
-    const matchFunc = match(`/${route.route}`.replace(/^\/\//, '/'), {
-      decode: decodeURIComponent,
-    })
-
-    // Attempt to match the request path
-    const matchedPath = matchFunc(requestPath.replace(/^\/\//, '/'))
-
-    if (matchedPath) {
-      // Aggregate global and route-specific middleware
-      const globalMiddleware = middleware
-        .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
-        .map((m) => m.middleware)
-        .flat()
-
-      const meta = pikkuState('http', 'meta').find(
-        (meta) => meta.route === route.route && meta.method === route.method
-      )
+  const matchedPath = httpRouter.match(
+    requestType.toLowerCase() as HTTPMethod,
+    requestPath
+  )
 
-      return {
-        matchedPath,
-        params: matchedPath.params,
-        route,
-        permissions: route.permissions,
-        middleware: [...globalMiddleware, ...(route.middleware || [])],
-        meta: meta!,
-      }
+  if (matchedPath) {
+    const route = pikkuState('http', 'routes')
+      .get(requestType.toLowerCase() as HTTPMethod)!
+      .get(matchedPath.route)!
+    const meta = pikkuState('http', 'meta')[
+      requestType.toLowerCase() as PikkuWiringTypes
+    ][route.route]
+
+    return {
+      matchedPath,
+      params: matchedPath.params,
+      route,
+      permissions: route.permissions,
+      httpMiddleware: matchedPath.middleware,
+      middleware: route.middleware,
+      meta: meta!,
     }
   }
-  return undefined
 }
 
 /**
@@ -251,7 +223,8 @@ const executeRouteWithMiddleware = async (
     matchedPath: any
     params: any
     route: CoreHTTPFunctionWiring<any, any, any>
-    middleware: any[]
+    httpMiddleware: CorePikkuMiddleware[] | undefined
+    middleware: CorePikkuMiddleware[] | undefined
     meta: HTTPWiringMeta
   },
   http: PikkuHTTP,
@@ -259,7 +232,8 @@ const executeRouteWithMiddleware = async (
     coerceDataFromSchema: boolean
   }
 ) => {
-  const { matchedPath, params, route, middleware, meta } = matchedRoute
+  const { matchedPath, params, route, httpMiddleware, middleware, meta } =
+    matchedRoute
   const {
     singletonServices,
     userSession,
@@ -347,14 +321,19 @@ const executeRouteWithMiddleware = async (
       })
     }
 
-    result = await runPikkuFunc(meta.pikkuFuncName, {
-      getAllServices,
-      session,
-      data,
-      permissions: route.permissions,
-      coerceDataFromSchema: options.coerceDataFromSchema,
-      tags: route.tags,
-    })
+    result = await runPikkuFunc(
+      PikkuWiringTypes.http,
+      `${meta.method}:${meta.route}`,
+      meta.pikkuFuncName,
+      {
+        getAllServices,
+        session,
+        data,
+        permissions: route.permissions,
+        coerceDataFromSchema: options.coerceDataFromSchema,
+        tags: route.tags,
+      }
+    )
 
     // Respond with either a binary or JSON response based on configuration
     if (route.returnsJSON === false) {
@@ -375,7 +354,8 @@ const executeRouteWithMiddleware = async (
   await runMiddleware(
     { ...singletonServices, userSession },
     { http },
-    combineMiddleware({
+    combineMiddleware(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, {
+      httpMiddleware,
       wiringMiddleware: middleware,
       wiringTags: route.tags,
       funcMiddleware: funcConfig?.middleware,
@@ -506,7 +486,8 @@ export const fetchData = async <In, Out>(
       ignoreMiddleware
         ? {
             ...matchedRoute,
-            middleware: [],
+            middleware: undefined,
+            httpMiddleware: undefined,
           }
         : matchedRoute,
       http!,

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

@@ -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

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')
+    })
+  })
+})