@pikku/core 0.11.1 → 0.11.2

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

@@ -56,13 +56,13 @@ export const wireMCPResource = <
 >(
   mcpResource: CoreMCPResource<PikkuFunctionConfig>
 ) => {
-  const resourcesMeta = pikkuState('mcp', 'resourcesMeta')
+  const resourcesMeta = pikkuState(null, '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 as any)
-  const resources = pikkuState('mcp', 'resources')
+  const resources = pikkuState(null, 'mcp', 'resources')
   if (resources.has(mcpResource.uri)) {
     throw new Error(`MCP resource already exists: ${mcpResource.uri}`)
   }
@@ -76,13 +76,13 @@ export const wireMCPTool = <
 >(
   mcpTool: CoreMCPTool<PikkuFunctionConfig>
 ) => {
-  const toolsMeta = pikkuState('mcp', 'toolsMeta')
+  const toolsMeta = pikkuState(null, 'mcp', 'toolsMeta')
   const mcpToolMeta = toolsMeta[mcpTool.name]
   if (!mcpToolMeta) {
     throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`)
   }
   addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func as any)
-  const tools = pikkuState('mcp', 'tools')
+  const tools = pikkuState(null, 'mcp', 'tools')
   if (tools.has(mcpTool.name)) {
     throw new Error(`MCP tool already exists: ${mcpTool.name}`)
   }
@@ -96,13 +96,13 @@ export const wireMCPPrompt = <
 >(
   mcpPrompt: CoreMCPPrompt<PikkuFunctionConfig>
 ) => {
-  const promptsMeta = pikkuState('mcp', 'promptsMeta')
+  const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta')
   const mcpPromptMeta = promptsMeta[mcpPrompt.name]
   if (!mcpPromptMeta) {
     throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`)
   }
   addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func as any)
-  const prompts = pikkuState('mcp', 'prompts')
+  const prompts = pikkuState(null, 'mcp', 'prompts')
   if (prompts.has(mcpPrompt.name)) {
     throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`)
   }
@@ -118,8 +118,8 @@ export async function runMCPResource(
   let pikkuFuncName: string | undefined
   let extractedParams: Record<string, string> = {}
 
-  const metas = pikkuState('mcp', 'resourcesMeta')
-  const endpoints = pikkuState('mcp', 'resources')
+  const metas = pikkuState(null, 'mcp', 'resourcesMeta')
+  const endpoints = pikkuState(null, 'mcp', 'resources')
 
   if (endpoints.has(uri)) {
     endpoint = endpoints.get(uri)
@@ -170,8 +170,8 @@ export async function runMCPTool(
   params: RunMCPEndpointParams,
   name: string
 ) {
-  const endpoint = pikkuState('mcp', 'tools').get(name)
-  const meta = pikkuState('mcp', 'toolsMeta')[name]
+  const endpoint = pikkuState(null, 'mcp', 'tools').get(name)
+  const meta = pikkuState(null, 'mcp', 'toolsMeta')[name]
   return await runMCPPikkuFunc(
     request,
     'tool',
@@ -187,8 +187,8 @@ export async function runMCPPrompt(
   params: RunMCPEndpointParams,
   name: string
 ) {
-  const endpoint = pikkuState('mcp', 'prompts').get(name)
-  const meta = pikkuState('mcp', 'promptsMeta')[name]
+  const endpoint = pikkuState(null, 'mcp', 'prompts').get(name)
+  const meta = pikkuState(null, 'mcp', 'promptsMeta')[name]
   return await runMCPPikkuFunc(
     request,
     'prompt',
@@ -242,11 +242,11 @@ async function runMCPPikkuFunc(
     // Get metadata for the MCP endpoint to access pre-resolved middleware
     let meta: any
     if (type === 'resource') {
-      meta = pikkuState('mcp', 'resourcesMeta')[name]
+      meta = pikkuState(null, 'mcp', 'resourcesMeta')[name]
     } else if (type === 'tool') {
-      meta = pikkuState('mcp', 'toolsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'toolsMeta')[name]
     } else if (type === 'prompt') {
-      meta = pikkuState('mcp', 'promptsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'promptsMeta')[name]
     }
 
     const result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncName, {
@@ -298,25 +298,25 @@ async function runMCPPikkuFunc(
 }
 
 export const getMCPTools = () => {
-  return pikkuState('mcp', 'tools')
+  return pikkuState(null, 'mcp', 'tools')
 }
 
 export const getMCPResources = () => {
-  return pikkuState('mcp', 'resources')
+  return pikkuState(null, 'mcp', 'resources')
 }
 
 export const getMCPResourcesMeta = () => {
-  return pikkuState('mcp', 'resourcesMeta')
+  return pikkuState(null, 'mcp', 'resourcesMeta')
 }
 
 export const getMCPToolsMeta = () => {
-  return pikkuState('mcp', 'toolsMeta')
+  return pikkuState(null, 'mcp', 'toolsMeta')
 }
 
 export const getMCPPrompts = () => {
-  return pikkuState('mcp', 'prompts')
+  return pikkuState(null, 'mcp', 'prompts')
 }
 
 export const getMCPPromptsMeta = () => {
-  return pikkuState('mcp', 'promptsMeta')
+  return pikkuState(null, 'mcp', 'promptsMeta')
 }

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

@@ -39,7 +39,7 @@ const createMockJob = (
 })
 
 const addTestQueueFunction = (pikkuFuncName: string) => {
-  pikkuState('function', 'meta')[pikkuFuncName] = {
+  pikkuState(null, 'function', 'meta')[pikkuFuncName] = {
     pikkuFuncName,
     inputSchemaName: null,
     outputSchemaName: null,
@@ -61,14 +61,14 @@ describe('wireQueueWorker', () => {
     }
 
     // Set up metadata first
-    pikkuState('queue', 'meta')['test-queue'] = {
+    pikkuState(null, 'queue', 'meta')['test-queue'] = {
       pikkuFuncName: 'queue_test-queue',
       queueName: 'test-queue',
     }
     addTestQueueFunction('queue_test-queue')
     wireQueueWorker(mockWorker)
 
-    const registrations = pikkuState('queue', 'registrations')
+    const registrations = pikkuState(null, 'queue', 'registrations')
     assert.equal(registrations.has('test-queue'), true)
     assert.equal(registrations.get('test-queue'), mockWorker)
   })
@@ -109,14 +109,14 @@ describe('wireQueueWorker', () => {
       tags: ['queue'],
     }
 
-    pikkuState('queue', 'meta')['worker-with-middleware'] = {
+    pikkuState(null, 'queue', 'meta')['worker-with-middleware'] = {
       pikkuFuncName: 'queue_worker-with-middleware',
       queueName: 'worker-with-middleware',
     }
     addTestQueueFunction('queue_worker-with-middleware')
     wireQueueWorker(mockWorker)
 
-    const registrations = pikkuState('queue', 'registrations')
+    const registrations = pikkuState(null, 'queue', 'registrations')
     const worker = registrations.get('worker-with-middleware')
     assert.equal(worker?.middleware?.length, 1)
     assert.deepEqual(worker?.tags, ['queue'])
@@ -133,7 +133,7 @@ describe('getQueueWorkers', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['test-queue'] = {
+    pikkuState(null, 'queue', 'meta')['test-queue'] = {
       pikkuFuncName: 'queue_test-queue',
       queueName: 'test-queue',
     }
@@ -162,7 +162,7 @@ describe('removeQueueWorker', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['removable-queue'] = {
+    pikkuState(null, 'queue', 'meta')['removable-queue'] = {
       pikkuFuncName: 'queue_removable-queue',
       queueName: 'removable-queue',
     }
@@ -209,7 +209,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['simple-queue'] = {
+    pikkuState(null, 'queue', 'meta')['simple-queue'] = {
       pikkuFuncName: 'queue_simple-queue',
       queueName: 'simple-queue',
     }
@@ -247,7 +247,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['fail-queue'] = {
+    pikkuState(null, 'queue', 'meta')['fail-queue'] = {
       pikkuFuncName: 'queue_fail-queue',
       queueName: 'fail-queue',
     }
@@ -285,7 +285,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['fail-no-reason-queue'] = {
+    pikkuState(null, 'queue', 'meta')['fail-no-reason-queue'] = {
       pikkuFuncName: 'queue_fail-no-reason-queue',
       queueName: 'fail-no-reason-queue',
     }
@@ -321,7 +321,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['discard-queue'] = {
+    pikkuState(null, 'queue', 'meta')['discard-queue'] = {
       pikkuFuncName: 'queue_discard-queue',
       queueName: 'discard-queue',
     }
@@ -364,7 +364,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['progress-queue'] = {
+    pikkuState(null, 'queue', 'meta')['progress-queue'] = {
       pikkuFuncName: 'queue_progress-queue',
       queueName: 'progress-queue',
     }
@@ -397,7 +397,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['default-progress-queue'] = {
+    pikkuState(null, 'queue', 'meta')['default-progress-queue'] = {
       pikkuFuncName: 'queue_default-progress-queue',
       queueName: 'default-progress-queue',
     }
@@ -431,7 +431,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['wire-queue'] = {
+    pikkuState(null, 'queue', 'meta')['wire-queue'] = {
       pikkuFuncName: 'queue_wire-queue',
       queueName: 'wire-queue',
     }
@@ -474,7 +474,7 @@ describe('runQueueJob', () => {
 
   test('should throw error when queue worker registration not found', async () => {
     // Add metadata but not registration
-    pikkuState('queue', 'meta')['no-registration-queue'] = {
+    pikkuState(null, 'queue', 'meta')['no-registration-queue'] = {
       pikkuFuncName: 'queue_no-registration-queue',
       queueName: 'no-registration-queue',
     }
@@ -509,7 +509,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['session-services-queue'] = {
+    pikkuState(null, 'queue', 'meta')['session-services-queue'] = {
       pikkuFuncName: 'queue_session-services-queue',
       queueName: 'session-services-queue',
     }
@@ -542,7 +542,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['error-queue'] = {
+    pikkuState(null, 'queue', 'meta')['error-queue'] = {
       pikkuFuncName: 'queue_error-queue',
       queueName: 'error-queue',
     }
@@ -591,7 +591,7 @@ describe('runQueueJob', () => {
       middleware: [middleware],
     }
 
-    pikkuState('queue', 'meta')['middleware-queue'] = {
+    pikkuState(null, 'queue', 'meta')['middleware-queue'] = {
       pikkuFuncName: 'queue_middleware-queue',
       queueName: 'middleware-queue',
     }
@@ -618,7 +618,7 @@ describe('runQueueJob', () => {
       },
     }
 
-    pikkuState('queue', 'meta')['debug-queue'] = {
+    pikkuState(null, 'queue', 'meta')['debug-queue'] = {
       pikkuFuncName: 'queue_debug-queue',
       queueName: 'debug-queue',
     }

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

@@ -52,7 +52,7 @@ export const wireQueueWorker = <
   queueWorker: CoreQueueWorker<PikkuFunctionConfig>
 ) => {
   // Get processor metadata
-  const meta = pikkuState('queue', 'meta')
+  const meta = pikkuState(null, 'queue', 'meta')
   const processorMeta = meta[queueWorker.queueName]
   if (!processorMeta) {
     throw new Error(
@@ -70,7 +70,7 @@ export const wireQueueWorker = <
   })
 
   // Store processor definition in state - runtime adapters will pick this up
-  const registrations = pikkuState('queue', 'registrations')
+  const registrations = pikkuState(null, 'queue', 'registrations')
   registrations.set(queueWorker.queueName, queueWorker)
 }
 
@@ -78,14 +78,14 @@ export const wireQueueWorker = <
  * Get all registered queue processors
  */
 export function getQueueWorkers(): Map<string, CoreQueueWorker> {
-  return pikkuState('queue', 'registrations')
+  return pikkuState(null, 'queue', 'registrations')
 }
 
 /**
  * Stop and remove a queue processor
  */
 export async function removeQueueWorker(name: string): Promise<void> {
-  const registrations = pikkuState('queue', 'registrations')
+  const registrations = pikkuState(null, 'queue', 'registrations')
   const registration = registrations.get(name)
 
   if (!registration) {
@@ -111,14 +111,14 @@ export async function runQueueJob({
 }): Promise<void> {
   const logger = singletonServices.logger
 
-  const meta = pikkuState('queue', 'meta')
+  const meta = pikkuState(null, 'queue', 'meta')
   const processorMeta = meta[job.queueName]
   if (!processorMeta) {
     throw new Error(`Processor metadata not found for: ${job.queueName}`)
   }
 
   // Get the queue worker registration to access middleware
-  const registrations = pikkuState('queue', 'registrations')
+  const registrations = pikkuState(null, 'queue', 'registrations')
   const queueWorker = registrations.get(job.queueName)
   if (!queueWorker) {
     throw new Error(`Queue worker registration not found for: ${job.queueName}`)

package/src/wirings/rpc/index.ts

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

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

@@ -2,15 +2,37 @@ import { CoreServices, PikkuWire } 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'
+import { PikkuRPC, ResolvedFunction } from './rpc-types.js'
 
-// Type for the RPC service configuration
-type RPCServiceConfig = {
-  coerceDataFromSchema: boolean
+/**
+ * Resolve a namespaced function reference to package and function names
+ * Uses pikkuState to look up the namespace -> package mapping
+ */
+const resolveNamespace = (
+  namespacedFunction: string
+): ResolvedFunction | null => {
+  const colonIndex = namespacedFunction.indexOf(':')
+  if (colonIndex === -1) {
+    return null
+  }
+
+  const namespace = namespacedFunction.substring(0, colonIndex)
+  const functionName = namespacedFunction.substring(colonIndex + 1)
+
+  const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
+  const packageName = externalPackages.get(namespace)
+  if (!packageName) {
+    return null
+  }
+
+  return {
+    package: packageName,
+    function: functionName,
+  }
 }
 
 const getPikkuFunctionName = (rpcName: string): string => {
-  const rpc = pikkuState('rpc', 'meta')
+  const rpc = pikkuState(null, 'rpc', 'meta')
   const rpcMeta = rpc[rpcName]
   if (!rpcMeta) {
     throw new Error(`RPC function not found: ${rpcName}`)
@@ -24,13 +46,12 @@ export class ContextAwareRPCService {
     private services: CoreServices,
     private wire: PikkuWire,
     private options: {
-      coerceDataFromSchema?: boolean
       requiresAuth?: boolean
     }
   ) {}
 
   public async rpcExposed(funcName: string, data: any): Promise<any> {
-    const functionMeta = pikkuState('function', 'meta')[funcName]
+    const functionMeta = pikkuState(null, 'function', 'meta')[funcName]
     if (!functionMeta) {
       throw new Error(`Function not found: ${funcName}`)
     }
@@ -55,6 +76,17 @@ export class ContextAwareRPCService {
           }
         : undefined,
     }
+
+    // Check if it's a namespaced function call (e.g., 'stripe:createCharge')
+    if (funcName.includes(':')) {
+      return this.invokeExternalPackageFunction<In, Out>(
+        funcName,
+        data,
+        updatedWire
+      )
+    }
+
+    // Main package function
     return runPikkuFunc<In, Out>(
       'rpc',
       funcName,
@@ -65,12 +97,60 @@ export class ContextAwareRPCService {
         // but is valid since we don't want to keep creating new wire services
         singletonServices: this.services,
         data: () => data,
-        coerceDataFromSchema: this.options.coerceDataFromSchema,
         wire: updatedWire,
       }
     )
   }
 
+  /**
+   * Invoke a function from an external package
+   * External packages register their functions in pikkuState under their package name.
+   * The function is executed using the parent services (shared singleton services).
+   * @private
+   */
+  private async invokeExternalPackageFunction<In = any, Out = any>(
+    namespacedFunction: string,
+    data: In,
+    wire: PikkuWire
+  ): Promise<Out> {
+    // Resolve namespace to package name
+    const resolved = resolveNamespace(namespacedFunction)
+    if (!resolved) {
+      throw new Error(
+        `Unknown namespace in function reference: ${namespacedFunction}. ` +
+          `Make sure the package is registered in externalPackages config.`
+      )
+    }
+
+    // Get the function meta from the external package
+    // External packages use function meta, not RPC meta
+    const externalFunctionMeta = pikkuState(
+      resolved.package,
+      'function',
+      'meta'
+    )
+    const funcMeta = externalFunctionMeta[resolved.function]
+    if (!funcMeta) {
+      throw new Error(
+        `Function '${resolved.function}' not found in package '${resolved.package}'. ` +
+          `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`
+      )
+    }
+    const funcName = funcMeta.pikkuFuncName || resolved.function
+
+    // Execute the function using runPikkuFunc with the external package's state
+    // We use the parent services (this.services) since external packages share services
+    // Pass the function's tags so tag-based middleware/permissions are applied
+    return runPikkuFunc<In, Out>('rpc', namespacedFunction, funcName, {
+      auth: this.options.requiresAuth,
+      singletonServices: this.services,
+      data: () => data,
+      wire,
+      packageName: resolved.package,
+      tags: funcMeta.tags,
+    })
+  }
+
   public async rpcWithWire<In = any, Out = any>(
     rpcName: string,
     data: In,
@@ -96,7 +176,6 @@ export class ContextAwareRPCService {
         auth: this.options.requiresAuth,
         singletonServices: this.services,
         data: () => data,
-        coerceDataFromSchema: this.options.coerceDataFromSchema,
         wire: mergedWire,
       }
     )
@@ -122,13 +201,6 @@ export class PikkuRPCService<
   Services extends CoreServices,
   TypedRPC = PikkuRPC,
 > {
-  private config?: RPCServiceConfig
-
-  // Initialize the RPC service with configuration
-  initialize(config: RPCServiceConfig) {
-    this.config = config
-  }
-
   // Convenience function for initializing
   getContextRPCService(
     services: Services,
@@ -137,7 +209,6 @@ export class PikkuRPCService<
     depth: number = 0
   ): TypedRPC {
     const serviceRPC = new ContextAwareRPCService(services, wire, {
-      coerceDataFromSchema: this.config?.coerceDataFromSchema,
       requiresAuth,
     })
     return {
@@ -153,8 +224,3 @@ export class PikkuRPCService<
 
 // Create a singleton instance
 export const rpcService = new PikkuRPCService()
-
-// Convenience function for initializing
-export const initialize = (config: RPCServiceConfig) => {
-  rpcService.initialize(config)
-}

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

@@ -17,3 +17,11 @@ export interface RPCHandler<Input, Output> {
   input: Input
   output: Output
 }
+
+/**
+ * Resolved function reference from namespace
+ */
+export interface ResolvedFunction {
+  package: string
+  function: string
+}

package/src/wirings/scheduler/log-schedulers.ts

@@ -6,7 +6,7 @@ import { Logger } from '../../services/index.js'
  * @param logger - A logger for logging information.
  */
 export const logSchedulers = (logger: Logger) => {
-  const scheduledTasks = pikkuState('scheduler', 'tasks')
+  const scheduledTasks = pikkuState(null, 'scheduler', 'tasks')
   if (scheduledTasks.size === 0) {
     logger.info('No scheduled tasks added')
     return