@pikku/core 0.9.11 → 0.10.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-endpoint-registry.ts

@@ -1,4 +1,4 @@
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 
 export interface MCPToolEndpoint {
   name: string

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,50 @@ 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,
+        inheritedPermissions: meta?.permissions,
+        wirePermissions: mcp.permissions,
+        tags: mcp.tags,
+        interaction,
+      }
     )
 
     return {

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

@@ -1,5 +1,39 @@
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
-import { CorePikkuMiddleware } from '../../types/core.types.js'
+import {
+  CorePermissionGroup,
+  CorePikkuFunctionConfig,
+  CorePikkuFunctionSessionless,
+  CorePikkuPermission,
+} from '../../function/functions.types.js'
+import {
+  CorePikkuMiddleware,
+  MiddlewareMetadata,
+  PermissionMetadata,
+} from '../../types/core.types.js'
+
+/**
+ * Extract URI parameters from MCP resource URI template.
+ * E.g., "user/{userId}/post/{postId}" => "userId" | "postId"
+ */
+type ExtractMCPURIParams<S extends string> =
+  S extends `${string}{${infer Param}}/${infer Rest}`
+    ? Param | ExtractMCPURIParams<Rest>
+    : S extends `${string}{${infer Param}}`
+      ? Param
+      : never
+
+/**
+ * Type-level assertion that MCP resource URI parameters are present in the input type.
+ * This ensures compile-time safety for URI parameter validation.
+ */
+export type AssertMCPResourceURIParams<In, URI extends string> =
+  ExtractMCPURIParams<URI> extends keyof In
+    ? unknown
+    : [
+        'Error: MCP Resource URI parameters',
+        ExtractMCPURIParams<URI>,
+        'not in input type',
+        keyof In,
+      ]
 
 export type PikkuMCP<Tools extends string = any> = {
   // elicitInput: <Input>(message: string) => Promise<{ action: string, content: Input }>
@@ -15,10 +49,12 @@ export type PikkuMCP<Tools extends string = any> = {
  */
 export type MCPResourceMeta = Record<
   string,
-  Omit<CoreMCPResource, 'func'> & {
+  Omit<CoreMCPResource, 'func' | 'middleware' | 'permissions'> & {
     pikkuFuncName: string
     inputSchema: string | null
     outputSchema: string | null
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
+    permissions?: PermissionMetadata[] // Pre-resolved permission chain (tag + explicit)
   }
 >
 
@@ -27,10 +63,12 @@ export type MCPResourceMeta = Record<
  */
 export type MCPToolMeta = Record<
   string,
-  Omit<CoreMCPTool, 'func'> & {
+  Omit<CoreMCPTool, 'func' | 'middleware' | 'permissions'> & {
     pikkuFuncName: string
     inputSchema: string | null
     outputSchema: string | null
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
+    permissions?: PermissionMetadata[] // Pre-resolved permission chain (tag + explicit)
   }
 >
 
@@ -39,7 +77,7 @@ export type MCPToolMeta = Record<
  */
 export type MCPPromptMeta = Record<
   string,
-  Omit<CoreMCPPrompt, 'func'> & {
+  Omit<CoreMCPPrompt, 'func' | 'middleware' | 'permissions'> & {
     pikkuFuncName: string
     inputSchema: string | null
     outputSchema: string | null
@@ -48,6 +86,8 @@ export type MCPPromptMeta = Record<
       description: string
       required: boolean
     }>
+    middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
+    permissions?: PermissionMetadata[] // Pre-resolved permission chain (tag + explicit)
   }
 >
 
@@ -55,49 +95,60 @@ export type MCPPromptMeta = Record<
  * Represents an MCP resource with specific properties.
  */
 export type CoreMCPResource<
-  PikkuFunction = CorePikkuFunctionSessionless<any, any>,
+  PikkuFunctionConfig = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  >,
+  PikkuPermission = CorePikkuPermission<any, any>,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   uri: string
   title: string
-  description?: string
+  description: string
   mimeType?: string
   size?: number
   streaming?: boolean
-  func: PikkuFunction
+  func: PikkuFunctionConfig
   tags?: string[]
   middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission>
 }
 
 /**
  * Represents an MCP tool with specific properties.
  */
 export type CoreMCPTool<
-  PikkuFunction = CorePikkuFunctionSessionless<any, any>,
+  PikkuFunctionConfig = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, any>
+  >,
+  PikkuPermission = CorePikkuPermission<any, any>,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   name: string
   title?: string
   description: string
-  annotations?: Record<string, any>
-  func: PikkuFunction
+  func: PikkuFunctionConfig
   tags?: string[]
   streaming?: boolean
   middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission>
 }
 
 /**
  * Represents an MCP prompt with specific properties.
  */
 export type CoreMCPPrompt<
-  PikkuFunction = CorePikkuFunctionSessionless<any, MCPPromptResponse>,
+  PikkuFunctionConfig = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<any, MCPPromptResponse>
+  >,
+  PikkuPermission = CorePikkuPermission<any, any>,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   name: string
-  description?: string
-  func: PikkuFunction
+  description: string
+  func: PikkuFunctionConfig
   tags?: string[]
   middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission>
 }
 
 export type JsonRpcRequest = {

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'