@pikku/core 0.12.0 → 0.12.1

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -1,14 +1,12 @@
 import { runPikkuFunc } from '../../function/function-runner.js'
-import { pikkuState } from '../../pikku-state.js'
-import { getDurationInMilliseconds } from '../../time-utils.js'
 import {
-  CoreConfig,
-  CoreSingletonServices,
-  CreateWireServices,
-  PikkuWire,
-  SerializedError,
-} from '../../types/core.types.js'
-import { QueueService } from '../queue/queue.types.js'
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../pikku-state.js'
+import { getDurationInMilliseconds } from '../../time-utils.js'
+import type { PikkuWire, SerializedError } from '../../types/core.types.js'
+import type { QueueService } from '../queue/queue.types.js'
 import type {
   PikkuWorkflowWire,
   StepState,
@@ -24,7 +22,7 @@ import {
   runWorkflowGraph,
   runFromMeta,
 } from './graph/graph-runner.js'
-import { WorkflowService } from '../../services/workflow-service.js'
+import type { WorkflowService } from '../../services/workflow-service.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import { RPCNotFoundError } from '../rpc/rpc-runner.js'
 
@@ -110,9 +108,6 @@ const WORKFLOW_END_STATES: ReadonlySet<string> = new Set([
  * Combines orchestration and step execution
  */
 export abstract class PikkuWorkflowService implements WorkflowService {
-  private config: WorkflowServiceConfig | undefined
-  private singletonServices: CoreSingletonServices | undefined
-  private createWireServices: CreateWireServices | undefined
   private inlineRuns = new Set<string>()
 
   constructor() {}
@@ -138,24 +133,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     this.inlineRuns.delete(runId)
   }
 
-  public setServices(
-    singletonServices: CoreSingletonServices,
-    createWireServices: CreateWireServices | undefined,
-    { workflow }: CoreConfig
-  ) {
-    this.singletonServices = singletonServices
-    this.createWireServices = createWireServices
-    this.config = {
-      retries: workflow?.retries ?? 0,
-      retryDelay: workflow?.retryDelay ?? 0,
-      orchestratorQueueName:
-        workflow?.orchestratorQueueName ?? 'pikku-workflow-orchestrator',
-      stepWorkerQueueName:
-        workflow?.stepWorkerQueueName ?? 'pikku-workflow-step-worker',
-      sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
-    }
-  }
-
   public async registerWorkflowVersions(): Promise<void> {
     const allMeta = pikkuState(null, 'workflows', 'meta')
     for (const [name, meta] of Object.entries(allMeta)) {
@@ -452,7 +429,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     // Check if this is a graph workflow (source === 'graph')
     if (workflowMeta.source === 'graph') {
       const shouldInline =
-        options?.inline || !this.singletonServices?.queueService
+        options?.inline || !getSingletonServices()?.queueService
       return runWorkflowGraph(
         this,
         name,
@@ -488,7 +465,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       this.inlineRuns.add(runId)
     }
 
-    if (options?.inline || !this.singletonServices?.queueService) {
+    if (options?.inline || !getSingletonServices()?.queueService) {
       this.runWorkflowJob(runId, rpcService)
         .catch(() => {})
         .finally(() => {
@@ -577,9 +554,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           workflowMeta.name,
           workflowMeta.pikkuFuncId,
           {
-            singletonServices: this.singletonServices!,
+            singletonServices: getSingletonServices()!,
             wire,
-            createWireServices: this.createWireServices,
+            createWireServices: getCreateWireServices(),
             data: () => run.input,
           }
         )
@@ -780,13 +757,13 @@ export abstract class PikkuWorkflowService implements WorkflowService {
   }
 
   private verifyQueueService(): QueueService {
-    if (!this.singletonServices?.queueService) {
+    if (!getSingletonServices()?.queueService) {
       throw new Error(
         'QueueService not configured. Remote workflows require a queue service.'
       )
     }
 
-    return this.singletonServices!.queueService
+    return getSingletonServices()!.queueService!
   }
 
   private async rpcStep(
@@ -839,12 +816,12 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     await this.setStepScheduled(stepState.stepId)
 
     // Enqueue step worker (unless inline mode)
-    if (!this.isInline(runId) && this.singletonServices!.queueService) {
+    if (!this.isInline(runId) && getSingletonServices()!.queueService) {
       // Map step retry options to queue job options
       const retries = stepOptions?.retries ?? 0
       const retryDelay = stepOptions?.retryDelay
 
-      await this.singletonServices!.queueService.add(
+      await getSingletonServices()!.queueService!.add(
         this.getConfig().stepWorkerQueueName,
         {
           runId,
@@ -1040,9 +1017,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     await this.setStepScheduled(stepState.stepId)
 
     // Check if inline mode or no scheduler service
-    if (!this.isInline(runId) && this.singletonServices!.schedulerService) {
+    if (!this.isInline(runId) && getSingletonServices()!.schedulerService) {
       // Remote mode - schedule sleep via scheduler service
-      await this.singletonServices!.schedulerService.scheduleRPC(
+      await getSingletonServices()!.schedulerService!.scheduleRPC(
         duration,
         this.getConfig().sleeperRPCName,
         {
@@ -1172,10 +1149,17 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     }
   }
 
-  private getConfig() {
-    if (!this.singletonServices || !this.config) {
-      throw new WorkflowServiceNotInitialized()
+  private getConfig(): WorkflowServiceConfig {
+    const singletonServices = getSingletonServices()
+    const workflow = singletonServices.config?.workflow
+    return {
+      retries: workflow?.retries ?? 0,
+      retryDelay: workflow?.retryDelay ?? 0,
+      orchestratorQueueName:
+        workflow?.orchestratorQueueName ?? 'pikku-workflow-orchestrator',
+      stepWorkerQueueName:
+        workflow?.stepWorkerQueueName ?? 'pikku-workflow-step-worker',
+      sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
     }
-    return this.config
   }
 }

package/src/wirings/workflow/workflow-helpers.test.ts

@@ -0,0 +1,129 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import {
+  workflow,
+  workflowStart,
+  workflowStatus,
+  graphStart,
+} from './workflow-helpers.js'
+
+describe('workflow helpers', () => {
+  describe('workflow', () => {
+    test('should return an object with func', () => {
+      const wf = workflow('myWorkflow')
+      assert.strictEqual(typeof wf.func, 'function')
+    })
+
+    test('func should call workflowService.runToCompletion', async () => {
+      const wf = workflow('myWorkflow', { pollIntervalMs: 500 })
+      let calledWith: any
+      const services = {
+        workflowService: {
+          runToCompletion: async (...args: any[]) => {
+            calledWith = args
+            return { result: 'done' }
+          },
+        },
+      }
+      const result = await wf.func(services, { input: 1 }, { rpc: {} })
+      assert.strictEqual(calledWith[0], 'myWorkflow')
+      assert.deepStrictEqual(calledWith[1], { input: 1 })
+      assert.deepStrictEqual(result, { result: 'done' })
+    })
+  })
+
+  describe('workflowStart', () => {
+    test('should return an object with func', () => {
+      const wfs = workflowStart('myWorkflow')
+      assert.strictEqual(typeof wfs.func, 'function')
+    })
+
+    test('func should call rpc.startWorkflow', async () => {
+      const wfs = workflowStart('myWorkflow')
+      let calledWith: any
+      const rpc = {
+        startWorkflow: async (...args: any[]) => {
+          calledWith = args
+          return { runId: 'run-1' }
+        },
+      }
+      const result = await wfs.func({}, { input: 1 }, { rpc })
+      assert.strictEqual(calledWith[0], 'myWorkflow')
+      assert.deepStrictEqual(calledWith[1], { input: 1 })
+      assert.deepStrictEqual(result, { runId: 'run-1' })
+    })
+  })
+
+  describe('workflowStatus', () => {
+    test('should return an object with func', () => {
+      const wfst = workflowStatus('myWorkflow')
+      assert.strictEqual(typeof wfst.func, 'function')
+    })
+
+    test('func should return run status', async () => {
+      const wfst = workflowStatus('myWorkflow')
+      const services = {
+        workflowService: {
+          getRun: async (runId: string) => ({
+            id: runId,
+            status: 'completed',
+            output: { data: 'ok' },
+          }),
+        },
+      }
+      const result = await wfst.func(services, { runId: 'run-1' })
+      assert.strictEqual(result.id, 'run-1')
+      assert.strictEqual(result.status, 'completed')
+      assert.deepStrictEqual(result.output, { data: 'ok' })
+    })
+
+    test('func should throw WorkflowRunNotFoundError for missing run', async () => {
+      const wfst = workflowStatus('myWorkflow')
+      const services = {
+        workflowService: { getRun: async () => null },
+      }
+      await assert.rejects(
+        () => wfst.func(services, { runId: 'non-existent' }),
+        (err: any) => err.message.includes('non-existent')
+      )
+    })
+
+    test('func should include error message when run has error', async () => {
+      const wfst = workflowStatus('myWorkflow')
+      const services = {
+        workflowService: {
+          getRun: async () => ({
+            id: 'run-2',
+            status: 'failed',
+            error: { message: 'step failed', name: 'Error' },
+          }),
+        },
+      }
+      const result = await wfst.func(services, { runId: 'run-2' })
+      assert.strictEqual(result.status, 'failed')
+      assert.deepStrictEqual(result.error, { message: 'step failed' })
+    })
+  })
+
+  describe('graphStart', () => {
+    test('should return an object with func', () => {
+      const gs = graphStart('myGraph', 'startNode')
+      assert.strictEqual(typeof gs.func, 'function')
+    })
+
+    test('func should call rpc.startWorkflow with startNode', async () => {
+      const gs = graphStart('myGraph', 'nodeA')
+      let calledWith: any
+      const rpc = {
+        startWorkflow: async (...args: any[]) => {
+          calledWith = args
+          return { runId: 'run-3' }
+        },
+      }
+      const result = await gs.func({}, { input: 1 }, { rpc })
+      assert.strictEqual(calledWith[0], 'myGraph')
+      assert.deepStrictEqual(calledWith[2], { startNode: 'nodeA' })
+      assert.deepStrictEqual(result, { runId: 'run-3' })
+    })
+  })
+})

package/src/wirings/workflow/workflow.types.ts

@@ -1,5 +1,5 @@
-import { SerializedError, CommonWireMeta } from '../../types/core.types.js'
-import { CorePikkuFunctionConfig } from '../../function/functions.types.js'
+import type { SerializedError, CommonWireMeta } from '../../types/core.types.js'
+import type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 
 // Re-export WorkflowService from services module
 export type { WorkflowService } from '../../services/workflow-service.js'