@pikku/core 0.10.2 → 0.11.0

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

@@ -49,11 +49,10 @@ export 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 @@ export 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'