@pikku/core 0.10.1 → 0.11.0

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

@@ -434,7 +434,7 @@ export async function executeCLI({
   args?: string[]
   createConfig: CreateConfig<any, any>
   createSingletonServices: CreateSingletonServices<any, any>
-  createSessionServices?: CreateSessionServices<any, any>
+  createSessionServices?: CreateSessionServices<any, any, any>
 }): Promise<void> {
   if (!args) {
     throw new Error(
@@ -449,7 +449,7 @@ export async function executeCLI({
       | undefined
     if (!allCLIMeta) {
       throw new Error(
-        '[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/errors/pku342 for more information.'
+        '[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.'
       )
     }
     const programMeta = allCLIMeta.programs[programName]

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

@@ -327,8 +327,6 @@ const executeRoute = async (
   const interaction: PikkuInteraction = { http, channel }
 
   const getAllServices = async (session?: CoreUserSession) => {
-    let channel: PikkuChannel<unknown, unknown> | undefined
-
     // Create session-specific services for handling the request
     sessionServices = await createSessionServices(
       { ...singletonServices, userSession, channel },

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

@@ -62,7 +62,7 @@ export const wireMCPResource = <
   if (!mcpResourceMeta) {
     throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`)
   }
-  addFunction(mcpResourceMeta.pikkuFuncName, mcpResource)
+  addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func as any)
   const resources = pikkuState('mcp', 'resources')
   if (resources.has(mcpResource.uri)) {
     throw new Error(`MCP resource already exists: ${mcpResource.uri}`)
@@ -160,7 +160,9 @@ export async function runMCPResource(
     uri,
     endpoint,
     pikkuFuncName,
-    { ...params, mcp: { uri } } as RunMCPEndpointParams<keyof CoreMCPResource>
+    { ...params, mcp: { ...params.mcp, uri } } as RunMCPEndpointParams<
+      keyof CoreMCPResource
+    >
   )
 }
 
@@ -250,6 +252,7 @@ async function runMCPPikkuFunc(
         {
           ...singletonServices,
           ...sessionServices,
+          mcp: mcpInteraction,
         },
         interaction
       )

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

@@ -1,4 +1,4 @@
-import type { CoreServices } from '../../types/core.types.js'
+import type { CoreServices, PikkuInteraction } from '../../types/core.types.js'
 import type { CoreQueueWorker, QueueJob, PikkuQueue } from './queue.types.js'
 import type {
   CorePikkuFunctionConfig,
@@ -11,6 +11,7 @@ import {
   CreateSessionServices,
   PikkuWiringTypes,
 } from '../../types/core.types.js'
+import { rpcService } from '../rpc/rpc-runner.js'
 
 /**
  * Error class for queue processor not found
@@ -149,6 +150,7 @@ export async function runQueueJob({
   try {
     logger.info(`Processing job ${job.id} in queue ${job.queueName}`)
 
+    const interaction: PikkuInteraction = { queue }
     // Use provided singleton services
     const getAllServices = async () => {
       const sessionServices = await createSessionServices?.(
@@ -157,10 +159,16 @@ export async function runQueueJob({
         undefined
       )
 
-      return {
-        ...singletonServices,
-        ...sessionServices,
-      }
+      const services = rpcService.injectRPCService(
+        {
+          ...singletonServices,
+          ...sessionServices,
+        },
+        interaction,
+        false
+      )
+
+      return services
     }
 
     // Execute the pikku function with the job data
@@ -176,7 +184,7 @@ export async function runQueueJob({
         inheritedMiddleware: processorMeta.middleware,
         wireMiddleware: queueWorker.middleware,
         tags: queueWorker.tags,
-        interaction: { queue },
+        interaction,
       }
     )
 

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

@@ -140,15 +140,12 @@ export interface QueueWorkers {
 
   /** Scan state and register all compatible processors */
   registerQueues(): Promise<Record<string, ConfigValidationResult[]>>
-
-  /** Close all queues and connections */
-  close(): Promise<void>
 }
 
 /**
  * Queue processor metadata
  */
-export type queueWorkersMeta = Record<
+export type QueueWorkersMeta = Record<
   string,
   {
     pikkuFuncName: string

package/src/wirings/rpc/index.ts

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

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

@@ -23,7 +23,7 @@ const getPikkuFunctionName = (rpcName: string): string => {
 }
 
 // Context-aware RPC client for use within services
-class ContextAwareRPCService {
+export class ContextAwareRPCService {
   constructor(
     private services: CoreServices,
     private interaction: PikkuInteraction,
@@ -49,11 +49,10 @@ class ContextAwareRPCService {
     data: In
   ): Promise<Out> {
     const rpcDepth = this.services.rpc?.depth || 0
-    const pikkuFuncName = getPikkuFunctionName(funcName)
     return runPikkuFunc<In, Out>(
       PikkuWiringTypes.rpc,
-      pikkuFuncName,
-      pikkuFuncName,
+      funcName,
+      getPikkuFunctionName(funcName),
       {
         auth: this.options.requiresAuth,
         singletonServices: this.services,
@@ -74,6 +73,58 @@ class ContextAwareRPCService {
       }
     )
   }
+
+  public async rpcWithInteraction<In = any, Out = any>(
+    funcName: string,
+    data: In,
+    interaction: PikkuInteraction
+  ): Promise<Out> {
+    const rpcDepth = this.services.rpc?.depth || 0
+    const mergedInteraction = {
+      ...this.interaction,
+      ...interaction,
+    }
+    return runPikkuFunc<In, Out>(
+      PikkuWiringTypes.rpc,
+      funcName,
+      getPikkuFunctionName(funcName),
+      {
+        auth: this.options.requiresAuth,
+        singletonServices: this.services,
+        getAllServices: () => {
+          this.services.rpc = this.services.rpc
+            ? ({
+                ...this.services.rpc,
+                depth: rpcDepth + 1,
+                global: false,
+              } as any)
+            : undefined
+          return {
+            ...this.services,
+            ...mergedInteraction,
+          }
+        },
+        data: () => data,
+        userSession: this.services.userSession,
+        coerceDataFromSchema: this.options.coerceDataFromSchema,
+        interaction: mergedInteraction,
+      }
+    )
+  }
+
+  public async startWorkflow<In = any>(
+    workflowName: string,
+    input: In
+  ): Promise<{ runId: string }> {
+    if (!this.services.workflowService) {
+      throw new Error('WorkflowService service not available')
+    }
+    return this.services.workflowService.startWorkflow(
+      workflowName,
+      input,
+      this
+    )
+  }
 }
 
 // RPC Service class for the global interface
@@ -107,6 +158,8 @@ export class PikkuRPCService<
       global: false,
       invoke: serviceRPC.rpc.bind(serviceRPC),
       invokeExposed: serviceRPC.rpc.bind(serviceRPC),
+      startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
+      rpcWithInteraction: serviceRPC.rpcWithInteraction.bind(serviceRPC),
     } as any
     return serviceCopy as Services & { rpc: TypedRPC }
   }

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

@@ -7,6 +7,7 @@ export type PikkuRPC<invoke extends Function = any> = {
 export type RPCMeta = {
   pikkuFuncName: string
   expose: boolean
+  internal?: boolean
 }
 
 /**

package/src/wirings/workflow/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Workflow module exports
+ */
+
+// Types
+export type {
+  CoreWorkflow,
+  WorkflowStepOptions,
+  WorkflowStepMeta,
+  PikkuWorkflowInteraction,
+  PikkuWorkflow,
+  WorkflowsMeta,
+  WorkflowRun,
+  StepState,
+  WorkflowStatus,
+  StepStatus,
+} from './workflow.types.js'
+
+export { PikkuWorkflowService } from './pikku-workflow-service.js'
+
+// Functions
+export { wireWorkflow } from './workflow-runner.js'