@pikku/core 0.9.11 → 0.9.12-next.0

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

@@ -2,35 +2,31 @@ 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 reset() {
+    this.compiledRoutes = new Map()
+    this.staticRoutes = new Map()
+    this.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 = (
@@ -51,40 +47,10 @@ export class PathToRegexRouter implements Router {
         // 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
@@ -95,7 +61,6 @@ export class PathToRegexRouter implements Router {
           methodCompiledRoutes.set(normalizedRoutePath, {
             matcher,
             route: routePath, // Keep the original route path for lookup in pikkuState
-            middleware: routeMiddleware,
           })
         }
       }
@@ -134,7 +99,6 @@ export class PathToRegexRouter implements Router {
         return {
           route: staticRoute.route,
           params: {},
-          middleware: staticRoute.middleware,
         }
       }
     }
@@ -152,7 +116,6 @@ export class PathToRegexRouter implements Router {
         return {
           route: compiledRoute.route,
           params: result.params,
-          middleware: compiledRoute.middleware,
         }
       }
     }

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

@@ -1,4 +1,5 @@
 import {
+  PikkuInteraction,
   PikkuWiringTypes,
   type CoreServices,
   type CoreSingletonServices,
@@ -14,14 +15,16 @@ import type {
   JsonRpcErrorResponse,
   PikkuMCP,
 } from './mcp.types.js'
-import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
+import type {
+  CorePikkuFunctionConfig,
+  CorePikkuFunctionSessionless,
+} from '../../function/functions.types.js'
 import { getErrorResponse } from '../../errors/error-handler.js'
 import { closeSessionServices } from '../../utils.js'
 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 { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
 
 export class MCPError extends Error {
   constructor(public readonly error: JsonRpcErrorResponse) {
@@ -32,7 +35,6 @@ export class MCPError extends Error {
 }
 
 export type RunMCPEndpointParams<Tools extends string = any> = {
-  session?: CoreUserSession
   singletonServices: CoreSingletonServices
   mcp?: PikkuMCP<Tools>
   createSessionServices?: CreateSessionServices<
@@ -49,16 +51,18 @@ export type JsonRpcError = {
 }
 
 export const wireMCPResource = <
-  PikkuFunction extends CorePikkuFunctionSessionless<any, any>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  > = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>,
 >(
-  mcpResource: CoreMCPResource<PikkuFunction>
+  mcpResource: CoreMCPResource<PikkuFunctionConfig>
 ) => {
   const resourcesMeta = pikkuState('mcp', 'resourcesMeta')
   const mcpResourceMeta = resourcesMeta[mcpResource.uri]
   if (!mcpResourceMeta) {
     throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`)
   }
-  addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func)
+  addFunction(mcpResourceMeta.pikkuFuncName, mcpResource)
   const resources = pikkuState('mcp', 'resources')
   if (resources.has(mcpResource.uri)) {
     throw new Error(`MCP resource already exists: ${mcpResource.uri}`)
@@ -67,9 +71,11 @@ export const wireMCPResource = <
 }
 
 export const wireMCPTool = <
-  PikkuFunction extends CorePikkuFunctionSessionless<any, any>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  > = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>,
 >(
-  mcpTool: CoreMCPTool<PikkuFunction>
+  mcpTool: CoreMCPTool<PikkuFunctionConfig>
 ) => {
   const toolsMeta = pikkuState('mcp', 'toolsMeta')
   const mcpToolMeta = toolsMeta[mcpTool.name]
@@ -85,9 +91,11 @@ export const wireMCPTool = <
 }
 
 export const wireMCPPrompt = <
-  PikkuFunction extends CorePikkuFunctionSessionless<any, any>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  > = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>,
 >(
-  mcpPrompt: CoreMCPPrompt<PikkuFunction>
+  mcpPrompt: CoreMCPPrompt<PikkuFunctionConfig>
 ) => {
   const promptsMeta = pikkuState('mcp', 'promptsMeta')
   const mcpPromptMeta = promptsMeta[mcpPrompt.name]
@@ -200,10 +208,9 @@ async function runMCPPikkuFunc(
   mcp: CoreMCPResource | CoreMCPTool | CoreMCPPrompt | undefined,
   pikkuFuncName: string | undefined,
   {
-    session,
     singletonServices,
     createSessionServices,
-    mcp: interaction,
+    mcp: mcpInteraction,
   }: RunMCPEndpointParams
 ): Promise<JsonRpcResponse> {
   let sessionServices: any
@@ -230,54 +237,48 @@ async function runMCPPikkuFunc(
 
     singletonServices.logger.debug(`Running MCP ${type}: ${name}`)
 
-    let result: any
-
-    // Main MCP execution logic wrapped for middleware handling
-    const runMain = async () => {
-      const getAllServices = async () => {
-        if (createSessionServices) {
-          const services = await createSessionServices(
-            singletonServices,
-            { mcp: interaction },
-            session
-          )
-          sessionServices = services
-          return rpcService.injectRPCService({
-            ...singletonServices,
-            ...services,
-            mcp: interaction,
-          })
-        }
-        return rpcService.injectRPCService({
-          ...singletonServices,
-          mcp: interaction,
-        })
-      }
+    const interaction: PikkuInteraction = { mcp: mcpInteraction }
+
+    const getAllServices = async () => {
+      sessionServices = await createSessionServices?.(
+        singletonServices,
+        interaction,
+        undefined
+      )
 
-      result = await runPikkuFunc(
-        PikkuWiringTypes.mcp,
-        `${type}:${name}`,
-        pikkuFuncName,
+      return rpcService.injectRPCService(
         {
-          getAllServices,
-          session,
-          data: request.params,
-          tags: mcp.tags,
-        }
+          ...singletonServices,
+          ...sessionServices,
+        },
+        interaction
       )
     }
 
-    const funcConfig = pikkuState('function', 'functions').get(pikkuFuncName!)
-    await runMiddleware(
-      singletonServices,
-      { mcp: interaction },
-      combineMiddleware(PikkuWiringTypes.mcp, `${type}:${name}`, {
-        wiringMiddleware: mcp.middleware,
-        wiringTags: mcp.tags,
-        funcMiddleware: funcConfig?.middleware,
-        funcTags: funcConfig?.tags,
-      }),
-      runMain
+    // Get metadata for the MCP endpoint to access pre-resolved middleware
+    let meta: any
+    if (type === 'resource') {
+      meta = pikkuState('mcp', 'resourcesMeta')[name]
+    } else if (type === 'tool') {
+      meta = pikkuState('mcp', 'toolsMeta')[name]
+    } else if (type === 'prompt') {
+      meta = pikkuState('mcp', 'promptsMeta')[name]
+    }
+
+    const result = await runPikkuFunc(
+      PikkuWiringTypes.mcp,
+      `${type}:${name}`,
+      pikkuFuncName,
+      {
+        singletonServices,
+        getAllServices,
+        userSession: undefined, // TODO
+        data: () => request.params,
+        inheritedMiddleware: meta?.middleware,
+        wireMiddleware: mcp.middleware,
+        tags: mcp.tags,
+        interaction,
+      }
     )
 
     return {

package/src/wirings/mcp/mcp.types.ts

@@ -1,5 +1,11 @@
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
-import { CorePikkuMiddleware } from '../../types/core.types.js'
+import {
+  CorePikkuFunctionConfig,
+  CorePikkuFunctionSessionless,
+} from '../../function/functions.types.js'
+import {
+  CorePikkuMiddleware,
+  MiddlewareMetadata,
+} from '../../types/core.types.js'
 
 export type PikkuMCP<Tools extends string = any> = {
   // elicitInput: <Input>(message: string) => Promise<{ action: string, content: Input }>
@@ -15,10 +21,11 @@ export type PikkuMCP<Tools extends string = any> = {
  */
 export type MCPResourceMeta = Record<
   string,
-  Omit<CoreMCPResource, 'func'> & {
+  Omit<CoreMCPResource, 'func' | 'middleware'> & {
     pikkuFuncName: string
     inputSchema: string | null
     outputSchema: string | null
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
   }
 >
 
@@ -27,10 +34,11 @@ export type MCPResourceMeta = Record<
  */
 export type MCPToolMeta = Record<
   string,
-  Omit<CoreMCPTool, 'func'> & {
+  Omit<CoreMCPTool, 'func' | 'middleware'> & {
     pikkuFuncName: string
     inputSchema: string | null
     outputSchema: string | null
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
   }
 >
 
@@ -39,7 +47,7 @@ export type MCPToolMeta = Record<
  */
 export type MCPPromptMeta = Record<
   string,
-  Omit<CoreMCPPrompt, 'func'> & {
+  Omit<CoreMCPPrompt, 'func' | 'middleware'> & {
     pikkuFuncName: string
     inputSchema: string | null
     outputSchema: string | null
@@ -48,6 +56,7 @@ export type MCPPromptMeta = Record<
       description: string
       required: boolean
     }>
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
   }
 >
 
@@ -55,7 +64,9 @@ export type MCPPromptMeta = Record<
  * Represents an MCP resource with specific properties.
  */
 export type CoreMCPResource<
-  PikkuFunction = CorePikkuFunctionSessionless<any, any>,
+  PikkuFunction = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  >,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   uri: string
@@ -73,7 +84,9 @@ export type CoreMCPResource<
  * Represents an MCP tool with specific properties.
  */
 export type CoreMCPTool<
-  PikkuFunction = CorePikkuFunctionSessionless<any, any>,
+  PikkuFunction = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  >,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   name: string
@@ -90,7 +103,9 @@ export type CoreMCPTool<
  * Represents an MCP prompt with specific properties.
  */
 export type CoreMCPPrompt<
-  PikkuFunction = CorePikkuFunctionSessionless<any, MCPPromptResponse>,
+  PikkuFunction = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, MCPPromptResponse>
+  >,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   name: string

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

@@ -1,6 +1,9 @@
 import type { CoreServices } from '../../types/core.types.js'
 import type { CoreQueueWorker, QueueJob, PikkuQueue } from './queue.types.js'
-import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
+import type {
+  CorePikkuFunctionConfig,
+  CorePikkuFunctionSessionless,
+} from '../../function/functions.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
@@ -8,7 +11,6 @@ import {
   CreateSessionServices,
   PikkuWiringTypes,
 } from '../../types/core.types.js'
-import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
 
 /**
  * Error class for queue processor not found
@@ -44,12 +46,13 @@ export class QueueJobDiscardedError extends PikkuError {
 export const wireQueueWorker = <
   InputData = any,
   OutputData = any,
-  PikkuFunction extends CorePikkuFunctionSessionless<
-    InputData,
-    OutputData
-  > = CorePikkuFunctionSessionless<InputData, OutputData>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<InputData, OutputData>
+  > = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<InputData, OutputData>
+  >,
 >(
-  queueWorker: CoreQueueWorker<PikkuFunction>
+  queueWorker: CoreQueueWorker<PikkuFunctionConfig>
 ) => {
   // Get processor metadata
   const meta = pikkuState('queue', 'meta')
@@ -61,7 +64,14 @@ export const wireQueueWorker = <
   }
 
   // Register the function with pikku
-  addFunction(processorMeta.pikkuFuncName, queueWorker.func)
+  addFunction(processorMeta.pikkuFuncName, {
+    func: queueWorker.func.func,
+    auth: queueWorker.func.auth,
+    permissions: queueWorker.func.permissions,
+    middleware: queueWorker.func.middleware as any,
+    tags: queueWorker.func.tags,
+    docs: queueWorker.func.docs as any,
+  })
 
   // Store processor definition in state - runtime adapters will pick this up
   const registrations = pikkuState('queue', 'registrations')
@@ -139,51 +149,38 @@ export async function runQueueJob({
   try {
     logger.info(`Processing job ${job.id} in queue ${job.queueName}`)
 
-    let result: any
-
-    // Main job execution logic wrapped for middleware handling
-    const runMain = async () => {
-      // Use provided singleton services
-      const getAllServices = () => ({
-        ...singletonServices,
-        ...(createSessionServices
-          ? createSessionServices(singletonServices, { queue }, undefined)
-          : {}),
-      })
-
-      // Execute the pikku function with the job data
-      result = await runPikkuFunc(
-        PikkuWiringTypes.queue,
-        job.queueName,
-        processorMeta.pikkuFuncName,
-        {
-          getAllServices,
-          data: job.data,
-          tags: queueWorker.tags,
-        }
+    // Use provided singleton services
+    const getAllServices = async () => {
+      const sessionServices = await createSessionServices?.(
+        singletonServices,
+        { queue },
+        undefined
       )
 
-      logger.debug(
-        `Successfully processed job ${job.id} in queue ${job.queueName}`
-      )
+      return {
+        ...singletonServices,
+        ...sessionServices,
+      }
     }
 
-    // Get function config for middleware and tags
-    const funcConfig = pikkuState('function', 'functions').get(
-      processorMeta.pikkuFuncName
+    // Execute the pikku function with the job data
+    const result = await runPikkuFunc(
+      PikkuWiringTypes.queue,
+      job.queueName,
+      processorMeta.pikkuFuncName,
+      {
+        singletonServices,
+        getAllServices,
+        data: () => job.data,
+        inheritedMiddleware: processorMeta.middleware,
+        wireMiddleware: queueWorker.middleware,
+        tags: queueWorker.tags,
+        interaction: { queue },
+      }
     )
 
-    // Get middleware for tags and combine with queue-specific middleware
-    await runMiddleware(
-      singletonServices,
-      { queue },
-      combineMiddleware(PikkuWiringTypes.queue, `${job.queueName}:${job.id}`, {
-        wiringMiddleware: queueWorker.middleware,
-        wiringTags: queueWorker.tags,
-        funcMiddleware: funcConfig?.middleware,
-        funcTags: funcConfig?.tags,
-      }),
-      runMain
+    logger.debug(
+      `Successfully processed job ${job.id} in queue ${job.queueName}`
     )
 
     return result

package/src/wirings/queue/queue.types.ts

@@ -1,5 +1,5 @@
-import { PikkuDocs, CorePikkuMiddleware } from '../../types/core.types.js'
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
+import { PikkuDocs, MiddlewareMetadata } from '../../types/core.types.js'
+import { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 import { QueueConfigMapping } from './validate-worker-config.js'
 
 /**
@@ -158,6 +158,7 @@ export type queueWorkersMeta = Record<
     docs?: PikkuDocs
     tags?: string[]
     config?: PikkuWorkerConfig
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
   }
 >
 
@@ -165,16 +166,19 @@ export type queueWorkersMeta = Record<
  * Core queue processor definition
  */
 export type CoreQueueWorker<
-  PikkuFunction = CorePikkuFunctionSessionless<any, any>,
-  PikkuMiddleware = CorePikkuMiddleware<any>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<
+    any,
+    any,
+    any
+  > = CorePikkuFunctionConfig<any, any, any>,
 > = {
   queueName: string
-  func: PikkuFunction
+  func: PikkuFunctionConfig
   config?: PikkuWorkerConfig
   docs?: PikkuDocs
   session?: undefined
   tags?: string[]
-  middleware?: PikkuMiddleware[]
+  middleware?: PikkuFunctionConfig['middleware']
 }
 
 /**

package/src/wirings/rpc/index.ts

@@ -1,2 +1,2 @@
-export { initialize } from './rpc-runner.js'
+export { initialize, PikkuRPCService } from './rpc-runner.js'
 export type { PikkuRPC, RPCMeta } from './rpc-types.js'

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

@@ -1,7 +1,12 @@
-import { CoreServices, PikkuWiringTypes } from '../../types/core.types.js'
+import {
+  CoreServices,
+  PikkuInteraction,
+  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'
+import { PikkuRPC } from './rpc-types.js'
 
 // Type for the RPC service configuration
 type RPCServiceConfig = {
@@ -21,8 +26,10 @@ const getPikkuFunctionName = (rpcName: string): string => {
 class ContextAwareRPCService {
   constructor(
     private services: CoreServices,
+    private interaction: PikkuInteraction,
     private options: {
       coerceDataFromSchema?: boolean
+      requiresAuth?: boolean
     }
   ) {}
 
@@ -41,7 +48,6 @@ class ContextAwareRPCService {
     funcName: string,
     data: In
   ): Promise<Out> {
-    const session = await this.services.userSession?.get()
     const rpcDepth = this.services.rpc?.depth || 0
     const pikkuFuncName = getPikkuFunctionName(funcName)
     return runPikkuFunc<In, Out>(
@@ -49,6 +55,8 @@ class ContextAwareRPCService {
       pikkuFuncName,
       pikkuFuncName,
       {
+        auth: this.options.requiresAuth,
+        singletonServices: this.services,
         getAllServices: () => {
           this.services.rpc = this.services.rpc
             ? ({
@@ -59,16 +67,20 @@ class ContextAwareRPCService {
             : undefined
           return this.services
         },
-        data,
-        session,
+        data: () => data,
+        userSession: this.services.userSession,
         coerceDataFromSchema: this.options.coerceDataFromSchema,
+        interaction: this.interaction,
       }
     )
   }
 }
 
 // RPC Service class for the global interface
-export class PikkuRPCService {
+export class PikkuRPCService<
+  Services extends CoreServices,
+  TypedRPC = PikkuRPC,
+> {
   private config?: RPCServiceConfig
 
   // Initialize the RPC service with configuration
@@ -77,12 +89,18 @@ export class PikkuRPCService {
   }
 
   // Convenience function for initializing
-  injectRPCService(coreServices: CoreServices, depth: number = 0) {
+  injectRPCService(
+    services: Services,
+    interaction: PikkuInteraction,
+    requiresAuth?: boolean | undefined,
+    depth: number = 0
+  ): Services & { rpc: TypedRPC } {
     const serviceCopy = {
-      ...coreServices,
+      ...services,
     }
-    const serviceRPC = new ContextAwareRPCService(serviceCopy, {
+    const serviceRPC = new ContextAwareRPCService(serviceCopy, interaction, {
       coerceDataFromSchema: this.config?.coerceDataFromSchema,
+      requiresAuth,
     })
     serviceCopy.rpc = {
       depth,
@@ -90,7 +108,7 @@ export class PikkuRPCService {
       invoke: serviceRPC.rpc.bind(serviceRPC),
       invokeExposed: serviceRPC.rpc.bind(serviceRPC),
     } as any
-    return serviceCopy
+    return serviceCopy as Services & { rpc: TypedRPC }
   }
 }