@pikku/core 0.12.78 → 0.12.80

package/src/testing/service-tests/secret-service-tests.ts

@@ -0,0 +1,105 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import type { ServiceTestConfig } from '../service-tests.js'
+
+/** Conformance suite for `secretService`. Runs only when a backend supplies one. */
+export const defineSecretServiceTests = (
+  name: string,
+  secretService: NonNullable<ServiceTestConfig['services']['secretService']>
+): void => {
+  const factory = secretService
+  const kek = 'test-key-encryption-key-32chars!'
+
+  describe(`SecretService [${name}]`, () => {
+    test('setSecret and getSecret', async () => {
+      const service = await factory({ key: kek })
+      await service.setSecret('api-key', {
+        token: 'sk-123',
+        endpoint: 'https://api.example.com',
+      })
+      const result = await service.getSecret<{
+        token: string
+        endpoint: string
+      }>('api-key')
+      assert.deepEqual(result.reveal(), {
+        token: 'sk-123',
+        endpoint: 'https://api.example.com',
+      })
+    })
+
+    test('getSecret wraps the raw string rather than returning it', async () => {
+      const service = await factory({ key: kek })
+      await service.setSecret('string-secret', 'plain-value')
+      const result = await service.getSecret('string-secret')
+      assert.strictEqual(result.reveal(), 'plain-value')
+    })
+
+    test('hasSecret returns true/false', async () => {
+      const service = await factory({ key: kek })
+      assert.strictEqual(await service.hasSecret('api-key'), true)
+      assert.strictEqual(await service.hasSecret('nonexistent'), false)
+    })
+
+    test('getSecret throws for missing key', async () => {
+      const service = await factory({ key: kek })
+      await assert.rejects(() => service.getSecret('nonexistent'), {
+        message: 'Requested secret not found',
+      })
+    })
+
+    test('setSecret upserts existing key', async () => {
+      const service = await factory({ key: kek })
+      await service.setSecret('upsert-key', { v: 1 })
+      await service.setSecret('upsert-key', { v: 2 })
+      const result = await service.getSecret<{ v: number }>('upsert-key')
+      assert.deepEqual(result.reveal(), { v: 2 })
+    })
+
+    test('deleteSecret removes the key', async () => {
+      const service = await factory({ key: kek })
+      await service.setSecret('to-delete', 'bye')
+      assert.strictEqual(await service.hasSecret('to-delete'), true)
+      await service.deleteSecret('to-delete')
+      assert.strictEqual(await service.hasSecret('to-delete'), false)
+    })
+
+    test('rotateKEK re-wraps all secrets', async () => {
+      const newKEK = 'new-key-encryption-key-rotated!'
+      const oldService = await factory({ key: kek })
+      await oldService.setSecret('rotate-test', { important: 'data' })
+
+      const rotatedService = await factory({
+        key: newKEK,
+        keyVersion: 2,
+        previousKey: kek,
+      })
+
+      const before = await rotatedService.getSecret<{
+        important: string
+      }>('rotate-test')
+      assert.deepEqual(before.reveal(), { important: 'data' })
+
+      assert.ok(rotatedService.rotateKEK)
+      const count = await rotatedService.rotateKEK!()
+      assert.ok(count > 0)
+
+      const newOnlyService = await factory({
+        key: newKEK,
+        keyVersion: 2,
+      })
+      const after = await newOnlyService.getSecret<{
+        important: string
+      }>('rotate-test')
+      assert.deepEqual(after.reveal(), { important: 'data' })
+    })
+
+    test('rotateKEK throws without previousKey', async () => {
+      const service = await factory({ key: kek })
+      assert.ok(service.rotateKEK)
+      await assert.rejects(() => service.rotateKEK!(), {
+        message: 'No previousKey configured — nothing to rotate from',
+      })
+    })
+  })
+}

package/src/testing/service-tests/session-store-tests.ts

@@ -0,0 +1,62 @@
+import { describe, test, before } from 'node:test'
+import assert from 'node:assert/strict'
+
+import type { SessionStore } from '../../services/session-store.js'
+import type { CoreUserSession } from '../../types/core.types.js'
+import type { ServiceTestConfig } from '../service-tests.js'
+
+type AppSession = CoreUserSession & Record<string, unknown>
+
+/** Conformance suite for `sessionStore`. Runs only when a backend supplies one. */
+export const defineSessionStoreTests = (
+  name: string,
+  sessionStore: NonNullable<ServiceTestConfig['services']['sessionStore']>
+): void => {
+  const factory = sessionStore
+  describe(`SessionStore [${name}]`, () => {
+    let store: SessionStore
+
+    before(async () => {
+      store = await factory()
+    })
+
+    test('get returns undefined for unknown user', async () => {
+      const result = await store.get('unknown-user')
+      assert.equal(result, undefined)
+    })
+
+    test('set and get round-trip', async () => {
+      const session: AppSession = {
+        userId: 'user-1',
+        organizationId: 'org-1',
+      }
+      await store.set('user-1', session)
+
+      const result = await store.get('user-1')
+      assert.deepEqual(result, session)
+    })
+
+    test('set overwrites previous session', async () => {
+      const asAdmin: AppSession = { userId: 'user-2', role: 'admin' }
+      const asMember: AppSession = { userId: 'user-2', role: 'member' }
+      await store.set('user-2', asAdmin)
+      await store.set('user-2', asMember)
+
+      const result = await store.get('user-2')
+      assert.deepEqual(result, { userId: 'user-2', role: 'member' })
+    })
+
+    test('clear removes session', async () => {
+      await store.set('user-3', { userId: 'user-3' })
+      assert.ok(await store.get('user-3'))
+
+      await store.clear('user-3')
+      const result = await store.get('user-3')
+      assert.equal(result, undefined)
+    })
+
+    test('clear is no-op for unknown user', async () => {
+      await store.clear('nonexistent')
+    })
+  })
+}

package/src/testing/service-tests/workflow-run-service-tests.ts

@@ -0,0 +1,59 @@
+import { describe, test, before } from 'node:test'
+import assert from 'node:assert/strict'
+
+import type { WorkflowRunService } from '../../wirings/workflow/workflow.types.js'
+import type { ServiceTestConfig } from '../service-tests.js'
+
+/** Conformance suite for `workflowRunService`. Runs only when a backend supplies one. */
+export const defineWorkflowRunServiceTests = (
+  name: string,
+  workflowRunService: NonNullable<
+    ServiceTestConfig['services']['workflowRunService']
+  >
+): void => {
+  const factory = workflowRunService
+  describe(`WorkflowRunService [${name}]`, () => {
+    let runService: WorkflowRunService
+
+    before(async () => {
+      runService = await factory()
+    })
+
+    test('listRuns returns runs', async () => {
+      const runs = await runService.listRuns()
+      assert.ok(Array.isArray(runs))
+      assert.ok(runs.length > 0)
+    })
+
+    test('listRuns with filter', async () => {
+      const runs = await runService.listRuns({
+        workflowName: 'test-workflow',
+      })
+      assert.ok(runs.every((r) => r.workflow === 'test-workflow'))
+    })
+
+    test('getDistinctWorkflowNames', async () => {
+      const names = await runService.getDistinctWorkflowNames()
+      assert.ok(Array.isArray(names))
+      assert.ok(names.includes('test-workflow'))
+    })
+
+    test('deleteRun', async () => {
+      const runs = await runService.listRuns({
+        workflowName: 'status-workflow',
+      })
+      assert.ok(runs.length > 0)
+
+      const deleted = await runService.deleteRun(runs[0]!.id)
+      assert.equal(deleted, true)
+
+      const afterDelete = await runService.getRun(runs[0]!.id)
+      assert.equal(afterDelete, null)
+    })
+
+    test('deleteRun returns false for missing', async () => {
+      const deleted = await runService.deleteRun('non-existent-id')
+      assert.equal(deleted, false)
+    })
+  })
+}

package/src/testing/service-tests/workflow-service-tests.ts

@@ -0,0 +1,308 @@
+import { describe, test, before } from 'node:test'
+import assert from 'node:assert/strict'
+
+import type { PikkuWorkflowService } from '../../wirings/workflow/pikku-workflow-service.js'
+import type { ServiceTestConfig } from '../service-tests.js'
+
+/** Conformance suite for `workflowService`. Runs only when a backend supplies one. */
+export const defineWorkflowServiceTests = (
+  name: string,
+  workflowService: NonNullable<ServiceTestConfig['services']['workflowService']>
+): void => {
+  const factory = workflowService
+  const wire = { type: 'test' }
+
+  describe(`WorkflowService [${name}]`, () => {
+    let service: PikkuWorkflowService
+
+    before(async () => {
+      service = await factory()
+    })
+
+    test('createRun and getRun', async () => {
+      const runId = await service.createRun(
+        'test-workflow',
+        { key: 'value' },
+        false,
+        'hash-1',
+        wire
+      )
+
+      assert.ok(runId)
+      const run = await service.getRun(runId)
+      assert.ok(run)
+      assert.equal(run.workflow, 'test-workflow')
+      assert.equal(run.status, 'running')
+      assert.deepEqual(run.input, { key: 'value' })
+      assert.equal(run.graphHash, 'hash-1')
+    })
+
+    test('updateRunStatus', async () => {
+      const runId = await service.createRun(
+        'status-workflow',
+        {},
+        false,
+        'hash-2',
+        wire
+      )
+      await service.updateRunStatus(runId, 'completed', { result: 'done' })
+
+      const run = await service.getRun(runId)
+      assert.ok(run)
+      assert.equal(run.status, 'completed')
+      assert.deepEqual(run.output, { result: 'done' })
+    })
+
+    test('insertStepState and getStepState', async () => {
+      const runId = await service.createRun(
+        'step-workflow',
+        {},
+        false,
+        'hash-3',
+        wire
+      )
+
+      const step = await service.insertStepState(
+        runId,
+        'step-1',
+        'myRpc',
+        { data: 'test' },
+        { retries: 3, retryDelay: '1000' }
+      )
+
+      assert.ok(step.stepId)
+      assert.equal(step.status, 'pending')
+      assert.equal(step.attemptCount, 1)
+      assert.equal(step.retries, 3)
+      assert.equal(step.retryDelay, '1000')
+
+      const fetched = await service.getStepState(runId, 'step-1')
+      assert.equal(fetched.stepId, step.stepId)
+      assert.equal(fetched.status, 'pending')
+      assert.equal(fetched.attemptCount, 1)
+    })
+
+    test('setStepRunning, setStepResult', async () => {
+      const runId = await service.createRun(
+        'result-workflow',
+        {},
+        false,
+        'hash-4',
+        wire
+      )
+      const step = await service.insertStepState(
+        runId,
+        'result-step',
+        'myRpc',
+        {}
+      )
+
+      await service.setStepRunning(step.stepId)
+      let fetched = await service.getStepState(runId, 'result-step')
+      assert.equal(fetched.status, 'running')
+
+      await service.setStepResult(step.stepId, { answer: 42 })
+      fetched = await service.getStepState(runId, 'result-step')
+      assert.equal(fetched.status, 'succeeded')
+      assert.deepEqual(fetched.result, { answer: 42 })
+    })
+
+    test('setStepError', async () => {
+      const runId = await service.createRun(
+        'error-workflow',
+        {},
+        false,
+        'hash-5',
+        wire
+      )
+      const step = await service.insertStepState(
+        runId,
+        'error-step',
+        'myRpc',
+        {}
+      )
+
+      await service.setStepRunning(step.stepId)
+      await service.setStepError(step.stepId, new Error('boom'))
+
+      const fetched = await service.getStepState(runId, 'error-step')
+      assert.equal(fetched.status, 'failed')
+      assert.equal(fetched.error?.message, 'boom')
+    })
+
+    test('createRetryAttempt', async () => {
+      const runId = await service.createRun(
+        'retry-workflow',
+        {},
+        false,
+        'hash-6',
+        wire
+      )
+      const step = await service.insertStepState(
+        runId,
+        'retry-step',
+        'myRpc',
+        {},
+        { retries: 2 }
+      )
+
+      await service.setStepError(step.stepId, new Error('fail'))
+      const retried = await service.createRetryAttempt(step.stepId, 'pending')
+      assert.equal(retried.status, 'pending')
+      assert.equal(retried.attemptCount, 2)
+      assert.equal(retried.error, undefined)
+      assert.equal(retried.result, undefined)
+    })
+
+    test('getRunStatus reports per-step duration and attempts', async () => {
+      const runId = await service.createRun(
+        'status-timing-workflow',
+        {},
+        false,
+        'hash-timing',
+        wire
+      )
+      const step = await service.insertStepState(
+        runId,
+        'timed-step',
+        'myRpc',
+        {}
+      )
+      await service.setStepRunning(step.stepId)
+      await service.setStepResult(step.stepId, { ok: true })
+
+      const status = await service.getRunStatus(runId)
+      assert.ok(status)
+      const timed = status.steps.find((s) => s.name === 'timed-step')
+      assert.ok(timed, 'step appears in run status')
+      // running→succeeded must stamp runningAt/succeededAt so a duration is
+      // computable. Regression guard: the kysely store previously updated
+      // only the status on transitions, leaving the timestamps null and
+      // duration permanently undefined.
+      assert.ok(
+        timed.duration !== undefined,
+        'duration is computed from stamped transition timestamps'
+      )
+      assert.ok(timed.duration >= 0, 'duration is non-negative')
+      assert.equal(timed.attempts, 1, 'single attempt')
+    })
+
+    test('getRunStatus surfaces retried attempt count', async () => {
+      const runId = await service.createRun(
+        'status-retry-workflow',
+        {},
+        false,
+        'hash-retry-status',
+        wire
+      )
+      const step = await service.insertStepState(
+        runId,
+        'flaky-step',
+        'myRpc',
+        {},
+        { retries: 2 }
+      )
+      await service.setStepRunning(step.stepId)
+      await service.setStepError(step.stepId, new Error('first try'))
+      // Guarantee the retry's history row sorts after the failed attempt so
+      // getRunStatus picks the latest attempt (it tie-breaks on timestamps).
+      await new Promise((resolve) => setTimeout(resolve, 5))
+      const retry = await service.createRetryAttempt(step.stepId, 'pending')
+      await service.setStepRunning(retry.stepId)
+      await service.setStepResult(retry.stepId, { ok: true })
+
+      const status = await service.getRunStatus(runId)
+      assert.ok(status)
+      const flaky = status.steps.find((s) => s.name === 'flaky-step')
+      assert.ok(flaky, 'retried step collapses to a single status entry')
+      assert.equal(flaky.status, 'succeeded', 'latest attempt wins')
+      assert.equal(flaky.attempts, 2, 'attempt count surfaces in status')
+    })
+
+    test('getNodeResults', async () => {
+      const runId = await service.createRun(
+        'results-workflow',
+        {},
+        false,
+        'hash-8',
+        wire
+      )
+      const step = await service.insertStepState(runId, 'node-a', 'rpc', {})
+      await service.setStepResult(step.stepId, { out: 'hello' })
+
+      const results = await service.getNodeResults(runId, ['node-a'])
+      assert.deepEqual(results['node-a'], { out: 'hello' })
+    })
+
+    test('setBranchTaken and getCompletedGraphState', async () => {
+      const runId = await service.createRun(
+        'branch-workflow',
+        {},
+        false,
+        'hash-9',
+        wire
+      )
+      const step = await service.insertStepState(
+        runId,
+        'branch-node',
+        'rpc',
+        {}
+      )
+      await service.setStepResult(step.stepId, {})
+      await service.setBranchTaken(step.stepId, 'left')
+
+      const state = await service.getCompletedGraphState(runId)
+      assert.ok(state.completedNodeIds.includes('branch-node'))
+      assert.equal(state.branchKeys['branch-node'], 'left')
+    })
+
+    test('updateRunState and getRunState', async () => {
+      const runId = await service.createRun(
+        'state-workflow',
+        {},
+        false,
+        'hash-10',
+        wire
+      )
+
+      await service.updateRunState(runId, 'counter', 5)
+      await service.updateRunState(runId, 'name', 'test')
+
+      const state = await service.getRunState(runId)
+      assert.equal(state.counter, 5)
+      assert.equal(state.name, 'test')
+    })
+
+    test('upsertWorkflowVersion and getWorkflowVersion', async () => {
+      await service.upsertWorkflowVersion(
+        'my-workflow',
+        'v1-hash',
+        { nodes: ['a', 'b'] },
+        'dsl'
+      )
+
+      const version = await service.getWorkflowVersion('my-workflow', 'v1-hash')
+      assert.ok(version)
+      assert.deepEqual(version.graph, { nodes: ['a', 'b'] })
+      assert.equal(version.source, 'dsl')
+    })
+
+    test('upsertWorkflowVersion duplicate is no-op', async () => {
+      await service.upsertWorkflowVersion(
+        'my-workflow',
+        'v1-hash',
+        { nodes: ['changed'] },
+        'dsl'
+      )
+
+      const version = await service.getWorkflowVersion('my-workflow', 'v1-hash')
+      assert.ok(version)
+      assert.deepEqual(version.graph, { nodes: ['a', 'b'] })
+    })
+
+    test('getWorkflowVersion returns null for missing', async () => {
+      const version = await service.getWorkflowVersion('missing', 'missing')
+      assert.equal(version, null)
+    })
+  })
+}