@pikku/core 0.12.0 → 0.12.1

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

@@ -0,0 +1,140 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'
+
+describe('validateAndBuildSecretDefinitionsMeta', () => {
+  test('should build meta from single definition', () => {
+    const definitions = [
+      {
+        name: 'stripe',
+        displayName: 'Stripe',
+        description: 'API key',
+        secretId: 'STRIPE_KEY',
+        sourceFile: 'a.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['stripe'])
+    assert.strictEqual(result['stripe'].secretId, 'STRIPE_KEY')
+    assert.strictEqual(result['stripe'].displayName, 'Stripe')
+  })
+
+  test('should allow duplicate secretId with same schema', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'Cred 1',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'Cred 2',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      schemaLookup
+    )
+    assert.ok(result['cred1'])
+    assert.ok(result['cred2'])
+  })
+
+  test('should throw when duplicate secretId has different schemas', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
+      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'Cred 1',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'Cred 2',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildSecretDefinitionsMeta(definitions as any, schemaLookup),
+      (err: any) => err.message.includes('different schemas')
+    )
+  })
+
+  test('should throw when duplicate secretId has different oauth2 configs', () => {
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'C1',
+        description: 'd',
+        secretId: 'OAUTH',
+        oauth2: { provider: 'google' },
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'C2',
+        description: 'd',
+        secretId: 'OAUTH',
+        oauth2: { provider: 'github' },
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildSecretDefinitionsMeta(definitions as any, new Map()),
+      (err: any) => err.message.includes('different configurations')
+    )
+  })
+
+  test('should handle empty definitions', () => {
+    const result = validateAndBuildSecretDefinitionsMeta([], new Map())
+    assert.deepStrictEqual(result, {})
+  })
+
+  test('should not duplicate names in meta', () => {
+    const definitions = [
+      {
+        name: 'same',
+        displayName: 'Same',
+        description: 'd',
+        secretId: 'KEY1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'same',
+        displayName: 'Same',
+        description: 'd',
+        secretId: 'KEY2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['same'])
+    assert.strictEqual(result['same'].secretId, 'KEY1')
+  })
+})

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

@@ -1,14 +1,12 @@
-import {
-  CoreSingletonServices,
-  CreateWireServices,
-  CoreServices,
-  CoreUserSession,
-} from '../../types/core.types.js'
 import { rpcService } from '../rpc/rpc-runner.js'
 import { setupTrigger } from './trigger-runner.js'
-import { TriggerInstance } from './trigger.types.js'
-import { TriggerService } from '../../services/trigger-service.js'
-import { pikkuState } from '../../pikku-state.js'
+import type { TriggerInstance } from './trigger.types.js'
+import type { TriggerService } from '../../services/trigger-service.js'
+import {
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../pikku-state.js'
 
 export type TriggerTarget = {
   targetType: 'rpc' | 'workflow'
@@ -23,34 +21,17 @@ export type TriggerSourceInfo = {
 
 export abstract class PikkuTriggerService implements TriggerService {
   protected activeTriggers = new Map<string, TriggerInstance>()
-  protected singletonServices?: CoreSingletonServices
-  protected createWireServices?: CreateWireServices<
-    CoreSingletonServices,
-    CoreServices,
-    CoreUserSession
-  >
-
-  setServices(
-    singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices<
-      CoreSingletonServices,
-      CoreServices,
-      CoreUserSession
-    >
-  ): void {
-    this.singletonServices = singletonServices
-    this.createWireServices = createWireServices
-  }
 
   abstract start(): Promise<void>
 
   async stop(): Promise<void> {
+    const singletonServices = getSingletonServices()
     for (const [name, instance] of this.activeTriggers) {
       try {
         await instance.teardown()
-        this.singletonServices!.logger.info(`Stopped trigger: ${name}`)
+        singletonServices.logger.info(`Stopped trigger: ${name}`)
       } catch (error) {
-        this.singletonServices!.logger.error(
+        singletonServices.logger.error(
           `Error stopping trigger ${name}: ${error}`
         )
       }
@@ -90,8 +71,6 @@ export abstract class PikkuTriggerService implements TriggerService {
   ): Promise<TriggerInstance> {
     return setupTrigger({
       name,
-      singletonServices: this.singletonServices!,
-      createWireServices: this.createWireServices as any,
       input,
       onTrigger,
     })
@@ -102,11 +81,10 @@ export abstract class PikkuTriggerService implements TriggerService {
     targets: TriggerTarget[],
     data: unknown
   ): Promise<void> {
-    const wireServices = await this.createWireServices?.(
-      this.singletonServices!,
-      {}
-    )
-    const services = { ...this.singletonServices!, ...wireServices }
+    const singletonServices = getSingletonServices()
+    const createWireServices = getCreateWireServices()
+    const wireServices = await createWireServices?.(singletonServices, {})
+    const services = { ...singletonServices, ...wireServices }
     const rpc = rpcService.getContextRPCService(services, {}, false)
 
     for (const target of targets) {
@@ -115,17 +93,17 @@ export abstract class PikkuTriggerService implements TriggerService {
           await rpc.startWorkflow(target.targetName, data, {
             startNode: target.startNode,
           })
-          this.singletonServices!.logger.info(
+          singletonServices.logger.info(
             `Trigger '${triggerName}' started workflow '${target.targetName}'`
           )
         } else {
           await rpc.invoke(target.targetName, data)
-          this.singletonServices!.logger.info(
+          singletonServices.logger.info(
             `Trigger '${triggerName}' invoked RPC '${target.targetName}'`
           )
         }
       } catch (error) {
-        this.singletonServices!.logger.error(
+        singletonServices.logger.error(
           `Error invoking ${target.targetType} '${target.targetName}' from trigger '${triggerName}': ${error}`
         )
       }

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

@@ -0,0 +1,79 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import {
+  wireTrigger,
+  wireTriggerSource,
+  getRegisteredTriggers,
+  getTriggerMeta,
+} from './trigger-runner.js'
+import { resetPikkuState, pikkuState } from '../../pikku-state.js'
+import { PikkuMissingMetaError } from '../../errors/errors.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('wireTrigger', () => {
+  test('should register a trigger when meta exists', () => {
+    const meta = pikkuState(null, 'trigger', 'meta')
+    ;(meta as any)['myTrigger'] = { pikkuFuncId: 'triggerFunc' }
+
+    wireTrigger({ name: 'myTrigger', func: async () => {} } as any)
+
+    const triggers = getRegisteredTriggers()
+    assert.ok(triggers.has('myTrigger'))
+  })
+
+  test('should throw PikkuMissingMetaError when meta is missing', () => {
+    assert.throws(
+      () => wireTrigger({ name: 'noMeta', func: async () => {} } as any),
+      (err: any) => err instanceof PikkuMissingMetaError
+    )
+  })
+})
+
+describe('wireTriggerSource', () => {
+  test('should register a trigger source when meta exists', () => {
+    const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
+    ;(sourceMeta as any)['mySource'] = { pikkuFuncId: 'sourceFunc' }
+
+    wireTriggerSource({ name: 'mySource', func: async () => {} } as any)
+
+    const sources = pikkuState(null, 'trigger', 'triggerSources')
+    assert.ok(sources.has('mySource'))
+  })
+
+  test('should throw PikkuMissingMetaError when source meta is missing', () => {
+    assert.throws(
+      () => wireTriggerSource({ name: 'noMeta', func: async () => {} } as any),
+      (err: any) => err instanceof PikkuMissingMetaError
+    )
+  })
+
+  test('should throw when trigger source already exists', () => {
+    const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
+    ;(sourceMeta as any)['dupSource'] = { pikkuFuncId: 'sourceFunc' }
+
+    wireTriggerSource({ name: 'dupSource', func: async () => {} } as any)
+
+    assert.throws(
+      () =>
+        wireTriggerSource({ name: 'dupSource', func: async () => {} } as any),
+      { message: 'Trigger source already exists: dupSource' }
+    )
+  })
+})
+
+describe('getRegisteredTriggers', () => {
+  test('should return the triggers Map', () => {
+    const triggers = getRegisteredTriggers()
+    assert.ok(triggers instanceof Map)
+  })
+})
+
+describe('getTriggerMeta', () => {
+  test('should return the trigger meta object', () => {
+    const meta = getTriggerMeta()
+    assert.ok(typeof meta === 'object')
+  })
+})

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'