@pikku/core 0.9.5 → 0.9.6

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,
@@ -253,19 +254,24 @@ 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,
+        }
+      )
     }
 
     const funcConfig = pikkuState('function', 'functions').get(pikkuFuncName!)
     await runMiddleware(
       singletonServices,
       { mcp: interaction },
-      combineMiddleware({
+      combineMiddleware(PikkuWiringTypes.mcp, `${type}:${name}`, {
         wiringMiddleware: mcp.middleware,
         wiringTags: mcp.tags,
         funcMiddleware: funcConfig?.middleware,

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

@@ -4,7 +4,10 @@ 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 {
+  CreateSessionServices,
+  PikkuWiringTypes,
+} from '../../types/core.types.js'
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
 
 /**
@@ -149,11 +152,16 @@ 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}`
@@ -169,7 +177,7 @@ export async function runQueueJob({
     await runMiddleware(
       singletonServices,
       { queue },
-      combineMiddleware({
+      combineMiddleware(PikkuWiringTypes.queue, `${job.queueName}:${job.id}`, {
         wiringMiddleware: queueWorker.middleware,
         wiringTags: queueWorker.tags,
         funcMiddleware: funcConfig?.middleware,

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

@@ -1,4 +1,4 @@
-import { CoreServices } from '../../types/core.types.js'
+import { CoreServices, PikkuWiringTypes } from '../../types/core.types.js'
 import { runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { ForbiddenError } from '../../errors/errors.js'
@@ -44,21 +44,26 @@ class ContextAwareRPCService {
     const session = await this.services.userSession?.get()
     const rpcDepth = this.services.rpc?.depth || 0
     const pikkuFuncName = getPikkuFunctionName(funcName)
-    return runPikkuFunc<In, Out>(pikkuFuncName, {
-      getAllServices: () => {
-        this.services.rpc = this.services.rpc
-          ? ({
-              ...this.services.rpc,
-              depth: rpcDepth + 1,
-              global: false,
-            } as any)
-          : undefined
-        return this.services
-      },
-      data,
-      session,
-      coerceDataFromSchema: this.options.coerceDataFromSchema,
-    })
+    return runPikkuFunc<In, Out>(
+      PikkuWiringTypes.rpc,
+      pikkuFuncName,
+      pikkuFuncName,
+      {
+        getAllServices: () => {
+          this.services.rpc = this.services.rpc
+            ? ({
+                ...this.services.rpc,
+                depth: rpcDepth + 1,
+                global: false,
+              } as any)
+            : undefined
+          return this.services
+        },
+        data,
+        session,
+        coerceDataFromSchema: this.options.coerceDataFromSchema,
+      }
+    )
   }
 }
 

package/src/wirings/scheduler/scheduler-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 {
   CoreScheduledTask,
@@ -115,12 +116,17 @@ export async function runScheduledTask({
         return singletonServices
       }
 
-      result = await runPikkuFunc(meta.pikkuFuncName, {
-        getAllServices,
-        session,
-        data: undefined,
-        tags: task.tags,
-      })
+      result = await runPikkuFunc(
+        PikkuWiringTypes.scheduler,
+        meta.name,
+        meta.pikkuFuncName,
+        {
+          getAllServices,
+          session,
+          data: undefined,
+          tags: task.tags,
+        }
+      )
     }
 
     const funcConfig = pikkuState('function', 'functions').get(
@@ -129,7 +135,7 @@ export async function runScheduledTask({
     await runMiddleware(
       singletonServices,
       { scheduledTask },
-      combineMiddleware({
+      combineMiddleware(PikkuWiringTypes.scheduler, meta.name, {
         wiringMiddleware: task.middleware,
         wiringTags: task.tags,
         funcMiddleware: funcConfig?.middleware,