@pikku/core 0.12.106 → 0.12.111

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

@@ -1,105 +0,0 @@
-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: nonexistent',
-      })
-    })
-
-    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

@@ -1,62 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,308 +0,0 @@
-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)
-    })
-  })
-}

package/src/testing/service-tests.ts

@@ -1,95 +0,0 @@
-import type { ChannelStore } from '../wirings/channel/channel-store.js'
-import type { EventHubStore } from '../wirings/channel/eventhub-store.js'
-import type { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js'
-import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js'
-import type { DeploymentService } from '../services/deployment-service.js'
-import type { AgentStorageService } from '../services/agent-storage-service.js'
-import type { AgentRunStateService } from '../services/agent-run-state-service.js'
-import type { SecretService } from '../services/secret-service.js'
-import type { CredentialService } from '../services/credential-service.js'
-import type { AgentRunService } from '../wirings/agent/agent.types.js'
-import type { SessionStore } from '../services/session-store.js'
-
-export interface ServiceTestConfig {
-  name: string
-  services: {
-    channelStore?: () => Promise<ChannelStore>
-    eventHubStore?: () => Promise<EventHubStore<Record<string, any>>>
-    workflowService?: () => Promise<PikkuWorkflowService>
-    workflowRunService?: () => Promise<WorkflowRunService>
-    deploymentService?: () => Promise<
-      DeploymentService & { stop(): Promise<void> }
-    >
-    agentStorageService?: () => Promise<
-      AgentStorageService & AgentRunStateService
-    >
-    agentRunService?: () => Promise<AgentRunService>
-    secretService?: (config: {
-      key: string
-      keyVersion?: number
-      previousKey?: string
-    }) => Promise<SecretService & { rotateKEK?(): Promise<number> }>
-    credentialService?: (config: {
-      key: string
-      keyVersion?: number
-      previousKey?: string
-    }) => Promise<CredentialService & { rotateKEK?(): Promise<number> }>
-    sessionStore?: () => Promise<SessionStore>
-  }
-}
-
-import { defineChannelStoreTests } from './service-tests/channel-store-tests.js'
-import { defineEventHubStoreTests } from './service-tests/event-hub-store-tests.js'
-import { defineWorkflowServiceTests } from './service-tests/workflow-service-tests.js'
-import { defineWorkflowRunServiceTests } from './service-tests/workflow-run-service-tests.js'
-import { defineAiStorageServiceTests } from './service-tests/agent-storage-service-tests.js'
-import { defineDeploymentServiceTests } from './service-tests/deployment-service-tests.js'
-import { defineSecretServiceTests } from './service-tests/secret-service-tests.js'
-import { defineCredentialServiceTests } from './service-tests/credential-service-tests.js'
-import { defineAgentRunServiceTests } from './service-tests/agent-run-service-tests.js'
-import { defineSessionStoreTests } from './service-tests/session-store-tests.js'
-
-/**
- * The shared conformance suite every storage backend runs.
- *
- * One module per service so a backend author can read the contract for the one
- * they implement; this dispatches to whichever the caller supplied.
- */
-export function defineServiceTests(config: ServiceTestConfig): void {
-  const { name, services } = config
-
-  if (services.channelStore) {
-    defineChannelStoreTests(name, services.channelStore)
-  }
-  if (services.eventHubStore) {
-    defineEventHubStoreTests(name, services.eventHubStore)
-  }
-  if (services.workflowService) {
-    defineWorkflowServiceTests(name, services.workflowService)
-  }
-  if (services.workflowRunService) {
-    defineWorkflowRunServiceTests(name, services.workflowRunService)
-  }
-  if (services.agentStorageService) {
-    defineAiStorageServiceTests(name, services.agentStorageService)
-  }
-  if (services.deploymentService) {
-    defineDeploymentServiceTests(name, services.deploymentService)
-  }
-  if (services.secretService) {
-    defineSecretServiceTests(name, services.secretService)
-  }
-  if (services.credentialService) {
-    defineCredentialServiceTests(name, services.credentialService)
-  }
-  if (services.agentRunService) {
-    defineAgentRunServiceTests(
-      name,
-      services.agentRunService,
-      services.agentStorageService
-    )
-  }
-  if (services.sessionStore) {
-    defineSessionStoreTests(name, services.sessionStore)
-  }
-}

package/src/time-utils.test.ts

@@ -1,56 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import type { RelativeTimeInput } from './time-utils'
-import {
-  getRelativeTimeOffset,
-  getRelativeTimeOffsetFromNow,
-} from './time-utils'
-
-const approxEqual = (a: number, b: number, delta: number = 10): boolean =>
-  Math.abs(a - b) <= delta
-
-describe('Time Utils', () => {
-  const offsetCases: Array<{ input: RelativeTimeInput; expected: number }> = [
-    { input: { value: 1, unit: 'second' }, expected: 1000 },
-    { input: { value: 2, unit: 'minute' }, expected: 120000 },
-    { input: { value: 1.5, unit: 'hour' }, expected: 5400000 },
-    { input: { value: -1, unit: 'day' }, expected: -86400000 },
-    { input: { value: 1, unit: 'week' }, expected: 604800000 },
-    {
-      input: { value: 2, unit: 'year' },
-      expected: Math.round(2 * 365.25 * 86400 * 1000),
-    },
-  ]
-
-  describe('getRelativeTimeOffset', () => {
-    for (const { input, expected } of offsetCases) {
-      test(`returns ${expected} ms for ${input.value} ${input.unit}`, () => {
-        const actual = getRelativeTimeOffset(input)
-        assert.strictEqual(actual, expected)
-      })
-    }
-  })
-
-  describe('getRelativeTimeOffsetFromNow', () => {
-    test('returns a Date ~1 minute in the future', () => {
-      const now = Date.now()
-      const result = getRelativeTimeOffsetFromNow({ value: 1, unit: 'minute' })
-      const delta = result.getTime() - now
-      assert.ok(
-        approxEqual(delta, 60000),
-        `Expected ~60000ms ahead, got ${delta}ms`
-      )
-    })
-
-    test('returns a Date ~2 hours in the past', () => {
-      const now = Date.now()
-      const result = getRelativeTimeOffsetFromNow({ value: -2, unit: 'hour' })
-      const delta = now - result.getTime()
-      assert.ok(
-        approxEqual(delta, 7200000),
-        `Expected ~7200000ms ago, got ${delta}ms`
-      )
-    })
-  })
-})