@pikku/core 0.12.0 → 0.12.2

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

@@ -1,14 +1,14 @@
-import {
-  PikkuWire,
-  CreateWireServices,
-  type CoreSingletonServices,
-} from '../../types/core.types.js'
+import type { PikkuWire } from '../../types/core.types.js'
 import type {
   CoreTrigger,
   CoreTriggerSource,
   TriggerInstance,
 } from './trigger.types.js'
-import { pikkuState } from '../../pikku-state.js'
+import {
+  pikkuState,
+  getSingletonServices,
+  getCreateWireServices,
+} from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { PikkuMissingMetaError } from '../../errors/errors.js'
 
@@ -66,8 +66,6 @@ export const wireTriggerSource = <TInput = unknown, TOutput = unknown>(
  */
 export type SetupTriggerParams<TInput = unknown, TOutput = unknown> = {
   name: string
-  singletonServices: CoreSingletonServices
-  createWireServices?: CreateWireServices
   input?: TInput
   onTrigger: (data: TOutput) => void | Promise<void>
 }
@@ -77,17 +75,16 @@ export type SetupTriggerParams<TInput = unknown, TOutput = unknown> = {
  * Returns a TriggerInstance with a teardown function.
  *
  * @param name - The trigger name (must be registered via wireTrigger)
- * @param singletonServices - The singleton services
  * @param input - The input to pass to the trigger function
  * @param onTrigger - Callback invoked when the trigger fires
  */
 export async function setupTrigger<TInput = unknown, TOutput = unknown>({
   name,
-  singletonServices,
-  createWireServices,
   input,
   onTrigger,
 }: SetupTriggerParams<TInput, TOutput>): Promise<TriggerInstance> {
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   const source = pikkuState(null, 'trigger', 'triggerSources').get(name)
   const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')[name]
 

package/src/wirings/variable/validate-variable-definitions.test.ts

@@ -0,0 +1,91 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { validateAndBuildVariableDefinitionsMeta } from './validate-variable-definitions.js'
+
+describe('validateAndBuildVariableDefinitionsMeta', () => {
+  test('should build meta from single definition', () => {
+    const definitions = [
+      {
+        name: 'dbUrl',
+        displayName: 'Database URL',
+        description: 'Connection string',
+        variableId: 'DB_URL',
+        sourceFile: 'a.ts',
+      },
+    ]
+    const result = validateAndBuildVariableDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['dbUrl'])
+    assert.strictEqual(result['dbUrl'].variableId, 'DB_URL')
+  })
+
+  test('should allow duplicate variableId with same schema', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'var1',
+        displayName: 'Var 1',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'var2',
+        displayName: 'Var 2',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildVariableDefinitionsMeta(
+      definitions as any,
+      schemaLookup
+    )
+    assert.ok(result['var1'])
+    assert.ok(result['var2'])
+  })
+
+  test('should throw when duplicate variableId has different schemas', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
+      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'var1',
+        displayName: 'Var 1',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'var2',
+        displayName: 'Var 2',
+        description: 'd',
+        variableId: 'SHARED',
+        schema: 'schema2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildVariableDefinitionsMeta(
+          definitions as any,
+          schemaLookup
+        ),
+      (err: any) => err.message.includes('different schemas')
+    )
+  })
+
+  test('should handle empty definitions', () => {
+    const result = validateAndBuildVariableDefinitionsMeta([], new Map())
+    assert.deepStrictEqual(result, {})
+  })
+})

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -196,19 +196,15 @@ describe('graph-runner bugs', () => {
     const ws = new InMemoryWorkflowService()
     const queuedNodes: string[] = []
 
-    ws.setServices(
-      {
-        queueService: {
-          add: async (_queueName: string, data: any) => {
-            if (data?.stepName) {
-              queuedNodes.push(data.stepName)
-            }
-          },
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async (_queueName: string, data: any) => {
+          if (data?.stepName) {
+            queuedNodes.push(data.stepName)
+          }
         },
-      } as any,
-      (() => ({})) as any,
-      {} as any
-    )
+      },
+    } as any)
 
     const meta: WorkflowRuntimeMeta = {
       name: 'testConvergingNextNode',
@@ -322,7 +318,7 @@ describe('graph-runner bugs', () => {
         true
       )
       runId = result.runId
-    } catch (_) {
+    } catch {
       const runs = (ws as any).runs as Map<string, any>
       for (const [id] of runs) {
         runId = id
@@ -344,15 +340,11 @@ describe('graph-runner bugs', () => {
   test('executeGraphStep should throw after queueing onError nodes', async () => {
     const ws = new InMemoryWorkflowService()
 
-    ws.setServices(
-      {
-        queueService: {
-          add: async () => {},
-        },
-      } as any,
-      (() => ({})) as any,
-      {} as any
-    )
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
 
     const metaState = pikkuState(null, 'workflows', 'meta')
     metaState['testQueuedOnErrorThrow'] = {

package/src/wirings/workflow/graph/template.test.ts

@@ -0,0 +1,49 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { template } from './template.js'
+
+describe('template', () => {
+  test('should parse a simple template with one placeholder', () => {
+    const result = template('Hello $0!', [{ $ref: 'greeting' }])
+    assert.deepStrictEqual(result.$template.parts, ['Hello ', '!'])
+    assert.deepStrictEqual(result.$template.expressions, [{ $ref: 'greeting' }])
+  })
+
+  test('should parse template with multiple placeholders', () => {
+    const result = template('$0 and $1', [{ $ref: 'a' }, { $ref: 'b' }])
+    assert.deepStrictEqual(result.$template.parts, ['', ' and ', ''])
+    assert.strictEqual(result.$template.expressions.length, 2)
+    assert.strictEqual(result.$template.expressions[0].$ref, 'a')
+    assert.strictEqual(result.$template.expressions[1].$ref, 'b')
+  })
+
+  test('should preserve path in references', () => {
+    const result = template('Value: $0', [{ $ref: 'node1', path: 'data.name' }])
+    assert.deepStrictEqual(result.$template.expressions[0], {
+      $ref: 'node1',
+      path: 'data.name',
+    })
+  })
+
+  test('should handle template with no placeholders', () => {
+    const result = template('No placeholders here', [])
+    assert.deepStrictEqual(result.$template.parts, ['No placeholders here'])
+    assert.deepStrictEqual(result.$template.expressions, [])
+  })
+
+  test('should handle out-of-range ref index as unknown', () => {
+    const result = template('$5', [{ $ref: 'a' }])
+    assert.deepStrictEqual(result.$template.expressions[0], { $ref: 'unknown' })
+  })
+
+  test('should handle adjacent placeholders', () => {
+    const result = template('$0$1', [{ $ref: 'a' }, { $ref: 'b' }])
+    assert.deepStrictEqual(result.$template.parts, ['', '', ''])
+    assert.strictEqual(result.$template.expressions.length, 2)
+  })
+
+  test('should omit path when not provided', () => {
+    const result = template('$0', [{ $ref: 'node' }])
+    assert.strictEqual(result.$template.expressions[0].path, undefined)
+  })
+})

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

@@ -16,15 +16,11 @@ describe('pikku-workflow-service version mismatch fallback', () => {
     const oldHash = 'old-hash'
     const newHash = 'new-hash'
 
-    ws.setServices(
-      {
-        queueService: {
-          add: async () => {},
-        },
-      } as any,
-      (() => ({})) as any,
-      {} as any
-    )
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
 
     const metaState = pikkuState(null, 'workflows', 'meta')
     metaState[workflowName] = {
@@ -111,15 +107,11 @@ describe('pikku-workflow-service version mismatch fallback', () => {
 describe('pikku-workflow-service executeWorkflowStep', () => {
   test('should set pending step to running before succeeding', async () => {
     const ws = new InMemoryWorkflowService()
-    ws.setServices(
-      {
-        queueService: {
-          add: async () => {},
-        },
-      } as any,
-      (() => ({})) as any,
-      {} as any
-    )
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
 
     const runId = await ws.createRun(
       'pending-step-running',
@@ -149,15 +141,11 @@ describe('pikku-workflow-service executeWorkflowStep', () => {
 describe('pikku-workflow-service suspend', () => {
   test('should set run status to suspended when workflow.suspend is called', async () => {
     const ws = new InMemoryWorkflowService()
-    ws.setServices(
-      {
-        queueService: {
-          add: async () => {},
-        },
-      } as any,
-      (() => ({})) as any,
-      {} as any
-    )
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {},
+      },
+    } as any)
 
     const workflowName = 'testSuspendWorkflow'
     const graphHash = 'suspend-hash'

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'